Merging upstream version 1.70.0+dfsg2.

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

63 files changed, 12939 insertions, 0 deletions

diff --git a/vendor/js-sys/.cargo-checksum.json b/vendor/js-sys/.cargo-checksum.json
new file mode 100644
index 000000000..e60e652d4
--- /dev/null
+++ b/vendor/js-sys/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"CHANGELOG.md":"3441ebc3918099baefa15652602bb1b2a06e1fc1de9d95e23079ef7b22832fdc","Cargo.toml":"f5194a77dfcfcc82e4a7b94fa60b08c0c7948ef215d358576849f5a9819f7d76","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397","README.md":"de73c6d7a9d9eac0674770fde362175700676be0dfaee0b22d4c75fdc28b068e","src/Temporal.rs":"6c3745bf5cbfbbaee3fabecd870c50669f7a4f1ee65fc96e2baa8f3e440cfe86","src/lib.rs":"209ee49d97af84ae42d9f6b55a5175b5db82ff052dc2e66662fe7f86f2167cfb","tests/headless.js":"dc0fdafb377cd6aa1415897083bbbf3d53c0ca39fc1691cc1f1fa7c528190491","tests/headless.rs":"f9eb68e88cc40fc81b7afad881fbdf2243d574f4417705226aa2102a71187e60","tests/wasm/Array.js":"c21d3d69f388ed4574fa7670c4a41240d0cfa2a374ed29f32f93069983138c72","tests/wasm/Array.rs":"c8916a57751c27fab2f73cda700794412ccf4863cbceaa50ea824d13ee76a631","tests/wasm/ArrayBuffer.rs":"a465e7cf7114e7466eb843f6612e22f00eb070dda15759bf8c62a1a3147a8c8d","tests/wasm/ArrayIterator.rs":"d849e50fbb8ebf6979e962c89210cf278176b15198c37f59cb15337e9c30ffa0","tests/wasm/BigInt.rs":"55a8070545f477acea07aebccad1bfd36bac88202923c357f894d6721046f53e","tests/wasm/Boolean.rs":"6091385e24f292a7e65809fa9cf3d328d8e65ad01fb976aef5daa2b5143224c3","tests/wasm/DataView.rs":"b1bea4a6235c406ca1df0e12daec95158c5fb663f3733a8cf986038770ae23a7","tests/wasm/Date.rs":"4de15246207a5f4c961f448dd18c743aa4ae45950571c9e4ec948272677bf584","tests/wasm/Error.rs":"3d593bdce1dee56fa2c35c290d499d687cc7f08971f89f7aa5f9b52d73af1546","tests/wasm/EvalError.rs":"638641bdd06bb43cffee89d37cd39ee615fe98d44d4c8278756a798a6593111f","tests/wasm/Function.js":"6c5876f74cf2838823470c4c007089baa17e2b28e4f602b65a4b2bc67073b9d7","tests/wasm/Function.rs":"2ccfd94e301b569d70face86d31843d095380973673a811302fb67d8d58378fe","tests/wasm/Generator.js":"7be85b1acbc2de5c3d9d8d64a396baf8c5a5b111905759315b3b395a22ea49e2","tests/wasm/Generator.rs":"860e51ccd01a06076b713445a2eff27244f5b349211a322aa9e3e8df2e76c8ce","tests/wasm/Intl.rs":"7da28d28423f925e9de5270d5c0e7bc4382a587c3c72864d142e15c2e6c7dc30","tests/wasm/Iterator.js":"525d29257a508e0cfcf4aa01dddd522d1dda6f8f968f271802ebd703e6f347d6","tests/wasm/Iterator.rs":"b2ac023d150179c0c3cd54f27f9b2775f62ad519111dc233e9ebbad5e9983193","tests/wasm/JSON.rs":"bc78a06047550271e38fa412fcb1220e49208933af6e136d7f99294240807da4","tests/wasm/JsString.js":"931aedd837c316bd7e1e2d52142a92d663e36b79995e2dde6d91c9d762095c13","tests/wasm/JsString.rs":"d5f5eff01b6ffb95e4512a1cae171537bb3ee36bbe9d17ca936714bd291b6683","tests/wasm/Map.rs":"022b4c26387190e36726b493615f9852ce40ed0c86a97db85bcf06e9086925f2","tests/wasm/MapIterator.rs":"ed0405dbc9a74885fc3c3614d08d5b7c9da2ad14e4b8d3c5f392ad03e12c61cc","tests/wasm/Math.rs":"0604f28481ac122ee88a5198c2b4f234e3f25e266f73c8e455973d486bcf4768","tests/wasm/Number.js":"a0b161084686deee75588a01834dea2bc12fde317d96bd3a0b73c825db71180f","tests/wasm/Number.rs":"ec02a3c8a39b7148b685b9b7d8bb8dd99cc33640c7e105b133c9de53eee71e10","tests/wasm/Object.js":"a8ab74505388012de784b2f62f00a57058632e02a3e4bf70f33fa0e5332ff384","tests/wasm/Object.rs":"851a89c9ec20a21ee88f05a3971a2c09baecd84bd4fb1847a8d30dad685ff2ae","tests/wasm/Promise.rs":"8c62a5c08cb43c60391f94e2d697d8925ba47069e19318a30fa64062ef372c8b","tests/wasm/Proxy.js":"63baac7050190339ed772fed09e4bd1845f34bcc36d7aa40ab2ecf93e9db786a","tests/wasm/Proxy.rs":"02d5ec8e5b781e12cdd96b38e643a4d0f6b725c0c904cc614bc83d829d501035","tests/wasm/RangeError.rs":"00a75d29880f53704c1ede81fb0f5c80efa8528a7c9f75b9f64d25234f74c3a4","tests/wasm/ReferenceError.rs":"47b60df993231f4631de2b9317bc1ac0a968976747f05d9b655dc61bcf2a58b4","tests/wasm/Reflect.js":"e5c43d410802ed45f38bffe60d0313dfcb978ac29a748258e889fbb3efa6d64a","tests/wasm/Reflect.rs":"f8bd8876b6bc1740652d51b6bad948eac7eb49541a08e2fe32a85043f9e0aa65","tests/wasm/RegExp.rs":"f91a9c838921832299185582900df6132dd5263fdcce4cc5342b6a1575d727b7","tests/wasm/Set.rs":"c22ca4651d472eedaadcfb03cfbb5c7d37f449cc073586db8ea97299f5d40b63","tests/wasm/SetIterator.rs":"0ad63f4852adcd91a40ffc1d95bb269e23bc338666acdc85a9516c492d5e1561","tests/wasm/SharedArrayBuffer.js":"6d30cec14dfc5890c8303cd1b81da235bce8a37d730232fc8b0d050f0e1db1b2","tests/wasm/SharedArrayBuffer.rs":"1cbf97431f693297d86de8477b3eb5c2f6e36111c0723d3de51ba9c677c5e289","tests/wasm/Symbol.js":"76c6c15f9fd34ffb7efddc90e898e12be074e9c98e066076a2b46f0554754de2","tests/wasm/Symbol.rs":"ae91d396b867bdfd9fd0c66b8863fb8e5c569886eeec98ae6cbd0ffad1a952a8","tests/wasm/SyntaxError.rs":"526ae9168f4979594e9d44f456e6b2816e38860ebf5937c2c905577aae5be7c0","tests/wasm/Temporal.js":"83312c76bdaa0893b7a6d638ccedb5a3d35f9beeb36977e608a739a81a2f4460","tests/wasm/Temporal.rs":"c7daa8e9e3f1e134ea08bb1a29879d8b515c6db3f7e53d1bc3af12ac4bae4ed8","tests/wasm/TypeError.rs":"618530b6556daad348106bd1c48c6dd808f54fe4efb344b15238db4ec3254d9f","tests/wasm/TypedArray.rs":"e6e1a350e10f7244eb669858d0a6d1e4a1007d57bd34508d685d2b6d43b38896","tests/wasm/UriError.rs":"2e695b4823e8875aa72c41aa6679e4d3f924adf47b763cb4462cf96ecdacfda6","tests/wasm/WeakMap.rs":"300bf589a0cfb0b0d3c3534222c949406bb3b9b408bc44cd54a72e3642987782","tests/wasm/WeakSet.rs":"321e780b427e4e4779c69839e6731840b1869d18ece0d71994ae1ef1fd804a8f","tests/wasm/WebAssembly.js":"5870c3811c8c17bab0b0e14c5ed62af987b8fa52382572a27cf704cded30f061","tests/wasm/WebAssembly.rs":"ddc4d36238a1b36ff9c949d4e9c73b7eb055c0c04b28cf262d2ccb55ffd7bc54","tests/wasm/global_fns.rs":"34e12bfd548b8710297087920599d97e31971d142a8b0c4acb5712f71f1213d3","tests/wasm/main.rs":"e07b9a62897df33dba3d0962f403b19574d5cd99cd2e08e316be364c7a73d7e7"},"package":"49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47"}
\ No newline at end of file
diff --git a/vendor/js-sys/CHANGELOG.md b/vendor/js-sys/CHANGELOG.md
new file mode 100644
index 000000000..f822008aa
--- /dev/null
+++ b/vendor/js-sys/CHANGELOG.md
@@ -0,0 +1,72 @@
+# `js-sys` Change Log
+
+--------------------------------------------------------------------------------
+
+## Unreleased
+
+Released YYYY-MM-DD.
+
+### Added
+
+* TODO (or remove section if none)
+
+### Changed
+
+* TODO (or remove section if none)
+
+### Deprecated
+
+* TODO (or remove section if none)
+
+### Removed
+
+* TODO (or remove section if none)
+
+### Fixed
+
+* TODO (or remove section if none)
+
+### Security
+
+* TODO (or remove section if none)
+
+--------------------------------------------------------------------------------
+
+## 0.2.1
+
+Released 2018-08-13.
+
+### Added
+
+* Added bindings to `Array.prototype.splice`.
+* Added bindings to `RegExp`.
+* Added bindings to `ArrayBuffer.prototype.byteLength`.
+* Started adding the `#[wasm_bindgen(extends = ...)]` attribute to various JS
+  types.
+* Added bindings to `EvalError`.
+* Added bindings to `Promise`. See the new `wasm-bindgen-futures` crate for
+  integrating JS `Promise`s into Rust `Future`s.
+* Added bindings to `JSON.{parse,stringify}`.
+* Added bindings to `Array.of`.
+* Added bindings to `Intl.Collator`.
+* Added bindings to `Object.assign`.
+* Added bindings to `Object.create`.
+* Added bindings to `RangeError`.
+* Added bindings to `ReferenceError`.
+* Added bindings to `Symbol.unscopables`.
+* Added bindings to `URIError`.
+* Added bindings to `SyntaxError`.
+* Added bindings to `TypeError`.
+
+### Changed
+
+* The `Intl` namespace was previously a bound object with static methods hanging
+  off of it. It is now a module with free functions, and nested types.
+
+--------------------------------------------------------------------------------
+
+## 0.2.0
+
+Released 2018-07-26.
+
+Initial release!
diff --git a/vendor/js-sys/Cargo.toml b/vendor/js-sys/Cargo.toml
new file mode 100644
index 000000000..a5643083a
--- /dev/null
+++ b/vendor/js-sys/Cargo.toml
@@ -0,0 +1,47 @@
+# 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 = "js-sys"
+version = "0.3.60"
+authors = ["The wasm-bindgen Developers"]
+description = """
+Bindings for all JS global objects and functions in all JS environments like
+Node.js and browsers, built on `#[wasm_bindgen]` using the `wasm-bindgen` crate.
+"""
+homepage = "https://rustwasm.github.io/wasm-bindgen/"
+documentation = "https://docs.rs/js-sys"
+readme = "./README.md"
+categories = ["wasm"]
+license = "MIT/Apache-2.0"
+repository = "https://github.com/rustwasm/wasm-bindgen/tree/master/crates/js-sys"
+
+[lib]
+test = false
+doctest = false
+
+[dependencies.wasm-bindgen]
+version = "0.2.83"
+
+[target."cfg(target_arch = \"wasm32\")".dev-dependencies.wasm-bindgen-futures]
+version = "0.4.33"
+
+[target."cfg(target_arch = \"wasm32\")".dev-dependencies.wasm-bindgen-test]
+version = "=0.3.33"
+
+[target."cfg(target_arch = \"wasm32\")".dev-dependencies.web-sys]
+version = "0.3.60"
+features = [
+    "Headers",
+    "Response",
+    "ResponseInit",
+]
diff --git a/vendor/js-sys/LICENSE-APACHE b/vendor/js-sys/LICENSE-APACHE
new file mode 100644
index 000000000..16fe87b06
--- /dev/null
+++ b/vendor/js-sys/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/js-sys/LICENSE-MIT b/vendor/js-sys/LICENSE-MIT
new file mode 100644
index 000000000..39e0ed660
--- /dev/null
+++ b/vendor/js-sys/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/js-sys/README.md b/vendor/js-sys/README.md
new file mode 100644
index 000000000..a5b0f2d97
--- /dev/null
+++ b/vendor/js-sys/README.md
@@ -0,0 +1,7 @@
+# `js-sys`
+
+[API documentation](https://rustwasm.github.io/wasm-bindgen/api/js_sys/)
+
+Raw bindings to JS global APIs for projects using `wasm-bindgen`. This crate is
+handwritten and intended to work in *all* JS environments like browsers and
+Node.js.
diff --git a/vendor/js-sys/src/Temporal.rs b/vendor/js-sys/src/Temporal.rs
new file mode 100644
index 000000000..ee6d97d17
--- /dev/null
+++ b/vendor/js-sys/src/Temporal.rs
@@ -0,0 +1,1057 @@
+use super::*;
+
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(js_namespace = Temporal, extends = Object)]
+    #[derive(Clone, Debug)]
+    pub type Instant;
+
+    #[wasm_bindgen(static_method_of = Instant, js_namespace = Temporal)]
+    pub fn from(val: &JsValue) -> Instant;
+
+    #[wasm_bindgen(static_method_of = Instant, js_namespace = Temporal)]
+    pub fn compare(one: &Instant, two: &Instant) -> i32;
+
+    #[wasm_bindgen(method, getter, structural, js_name = epochSeconds)]
+    pub fn epoch_seconds(this: &Instant) -> u64;
+    #[wasm_bindgen(method, getter, structural, js_name = epochMilliseconds)]
+    pub fn epoch_milliseconds(this: &Instant) -> u64;
+    #[wasm_bindgen(method, getter, structural, js_name = epochMicroseconds)]
+    pub fn epoch_microseconds(this: &Instant) -> BigInt;
+    #[wasm_bindgen(method, getter, structural, js_name = epochNanoseconds)]
+    pub fn epoch_nanoseconds(this: &Instant) -> BigInt;
+
+    /// This method adds duration to Instant.
+    ///
+    /// The years, months, weeks, and days fields of duration must be zero.
+    #[wasm_bindgen(method)]
+    pub fn add(this: &Instant, duration: &Duration, options: &JsValue) -> Instant;
+
+    /// This method subtracts duration to Instant.
+    ///
+    /// The years, months, weeks, and days fields of duration must be zero.
+    #[wasm_bindgen(method)]
+    pub fn subtract(this: &Instant, duration: &Duration, options: &JsValue) -> Instant;
+
+    /// This method computes the difference between the two times represented by zonedDateTime and
+    /// other, optionally rounds it, and returns it as a Temporal.Duration object. If other is earlier
+    /// than zonedDateTime then the resulting duration will be negative. The returned Temporal.Duration, when
+    /// added to zonedDateTime with the same options, will yield other.
+    #[wasm_bindgen(method)]
+    pub fn until(this: &Instant, other: &Instant, options: &JsValue) -> Duration;
+
+    /// This method computes the difference between the two times represented by zonedDateTime and
+    /// other, optionally rounds it, and returns it as a Temporal.Duration object. If other is later
+    /// than zonedDateTime then the resulting duration will be negative. The returned Temporal.Duration, when
+    /// added to zonedDateTime with the same options, will yield other.    
+    #[wasm_bindgen(method)]
+    pub fn since(this: &Instant, other: &Instant, options: &JsValue) -> Duration;
+
+    /// Returns a new Temporal.Instant object which is zonedDateTime rounded to `roundTo` (if
+    /// a string parameter is used) or `roundingIncrement` of `smallestUnit` (if an object parameter
+    /// is used).
+    #[wasm_bindgen(method)]
+    pub fn round(this: &Instant, round_to: &JsValue) -> Instant;
+
+    #[wasm_bindgen(method)]
+    pub fn equals(this: &Instant, other: &Instant) -> bool;
+
+    /// This method overrides the Object.prototype.toString() method and provides a convenient, unambiguous
+    /// string representation of date. The string can be passed to Temporal.PlainDate.from() to
+    /// create a new Temporal.PlainDate object.
+    #[wasm_bindgen(method, js_name = toString)]
+    pub fn to_string(this: &Instant) -> JsString;
+
+    /// This method overrides `Object.prototype.toLocaleString()` to provide a human-readable,
+    /// language-sensitive representation of duration.
+    ///
+    /// The locales and options arguments are the same as in the constructor to Intl.DateTimeFormat.
+    #[wasm_bindgen(method, js_name = toLocaleString)]
+    pub fn to_locale_string(this: &Instant, locales: &JsValue, options: &JsValue) -> JsString;
+
+}
+
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(js_namespace = Temporal, extends = Object)]
+    #[derive(Clone, Debug)]
+    pub type PlainDateTime;
+
+    #[wasm_bindgen(static_method_of = PlainDateTime, js_namespace = Temporal)]
+    pub fn from(val: &JsValue) -> PlainDateTime;
+
+    #[wasm_bindgen(static_method_of = PlainDateTime, js_namespace = Temporal)]
+    pub fn compare(one: &PlainDateTime, two: &PlainDateTime) -> i32;
+
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn year(this: &PlainDateTime) -> i32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn month(this: &PlainDateTime) -> u32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn week(this: &PlainDateTime) -> u32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn day(this: &PlainDateTime) -> u32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn hour(this: &PlainDateTime) -> u32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn minute(this: &PlainDateTime) -> u32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn second(this: &PlainDateTime) -> u32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn millisecond(this: &PlainDateTime) -> u32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn microsecond(this: &PlainDateTime) -> u32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn nanosecond(this: &PlainDateTime) -> u32;
+
+    /// In calendars that use eras, the era and eraYear read-only properties can be used
+    /// together to resolve an era-relative year. Both properties are undefined when using
+    /// the ISO 8601 calendar. As inputs to from or with, era and eraYear can be used instead
+    /// of year. Unlike year, eraYear may decrease as time proceeds because some
+    /// eras (like the BCE era in the Gregorian calendar) count years backwards.
+    #[wasm_bindgen(method, getter, structural, js_name = eraYear)]
+    pub fn era_year(this: &PlainDateTime) -> JsValue;
+
+    /// In calendars that use eras, the era and eraYear read-only properties can be used
+    /// together to resolve an era-relative year. Both properties are undefined when using
+    /// the ISO 8601 calendar. As inputs to from or with, era and eraYear can be used instead
+    /// of year. Unlike year, eraYear may decrease as time proceeds because some
+    /// eras (like the BCE era in the Gregorian calendar) count years backwards.
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn era(this: &PlainDateTime) -> JsValue;
+
+    /// The dayOfWeek read-only property gives the weekday number that the date falls
+    /// on. For the ISO 8601 calendar, the weekday number is defined as in the ISO 8601
+    /// standard: a value between 1 and 7, inclusive, with Monday being 1, and Sunday 7.
+    #[wasm_bindgen(method, getter, structural, js_name = dayOfWeek)]
+    pub fn day_of_week(this: &PlainDateTime) -> u32;
+
+    /// The dayOfYear read-only property gives the ordinal day of the year that the date
+    /// falls on. For the ISO 8601 calendar, this is a value between 1 and 365, or 366 in
+    /// a leap year.
+    #[wasm_bindgen(method, getter, structural, js_name = dayOfYear)]
+    pub fn day_of_year(this: &PlainDateTime) -> u32;
+
+    /// The weekOfYear read-only property gives the ISO week number of the date. For the
+    /// ISO 8601 calendar, this is normally a value between 1 and 52, but in a few cases it
+    /// can be 53 as well. ISO week 1 is the week containing the first Thursday of the year.
+    #[wasm_bindgen(method, getter, structural, js_name = weekOfYear)]
+    pub fn week_of_year(this: &PlainDateTime) -> u32;
+
+    /// The daysInWeek read-only property gives the number of days in the week that the
+    /// date falls in. For the ISO 8601 calendar, this is always 7, but in other calendar
+    /// systems it may differ from week to week.
+    #[wasm_bindgen(method, getter, structural, js_name = daysInWeek)]
+    pub fn days_in_week(this: &PlainDateTime) -> u32;
+
+    /// The daysInMonth read-only property gives the number of days in the month that the
+    /// date falls in. For the ISO 8601 calendar, this is 28, 29, 30, or 31, depending
+    /// on the month and whether the year is a leap year.
+    #[wasm_bindgen(method, getter, structural, js_name = daysInMonth)]
+    pub fn days_in_month(this: &PlainDateTime) -> u32;
+
+    /// The daysInYear read-only property gives the number of days in the year that the date
+    /// falls in. For the ISO 8601 calendar, this is 365 or 366, depending on whether the year
+    /// is a leap year.
+    #[wasm_bindgen(method, getter, structural, js_name = daysInYear)]
+    pub fn days_in_year(this: &PlainDateTime) -> u32;
+
+    /// The monthsInYear read-only property gives the number of months in the year that the date
+    /// falls in. For the ISO 8601 calendar, this is always 12, but in other calendar systems
+    /// it may differ from year to year.
+    #[wasm_bindgen(method, getter, structural, js_name = monthsInWeek)]
+    pub fn months_in_year(this: &PlainDateTime) -> u32;
+
+    /// The inLeapYear read-only property tells whether the year that the date falls in is a
+    /// leap year or not. Its value is true if the year is a leap year, and false if not.
+    #[wasm_bindgen(method, getter, structural, js_name = inLeapYear)]
+    pub fn in_leap_year(this: &PlainDateTime) -> bool;
+
+    /// This method creates a new Temporal.PlainDateTime which is a copy of zonedDateTime, but any
+    /// properties present on parameter override the ones already present on zonedDateTime.
+    #[wasm_bindgen(method, js_name = withPlainDate)]
+    pub fn with(this: &PlainDateTime, parameter: &JsValue, options: &JsValue) -> PlainDateTime;
+
+    /// Returns a new `Temporal.PlainDateTime` object which replaces the calendar date of zonedDateTime
+    /// with the calendar date represented by plainDate.
+    #[wasm_bindgen(method, js_name = withPlainDate)]
+    pub fn with_plain_date(this: &PlainDateTime, date: &PlainDate) -> PlainDateTime;
+
+    /// Returns a new `Temporal.PlainDateTime` object which is the date indicated by date, projected
+    /// into calendar.
+    #[wasm_bindgen(method, js_name = withCalendar)]
+    pub fn with_calendar(this: &PlainDateTime, calendar: &str) -> PlainDateTime;
+
+    /// This method adds duration to zonedDateTime.
+    #[wasm_bindgen(method)]
+    pub fn add(this: &PlainDateTime, duration: &Duration, options: &JsValue) -> PlainDateTime;
+
+    /// This method subtracts duration to zonedDateTime.
+    #[wasm_bindgen(method)]
+    pub fn subtract(this: &PlainDateTime, duration: &Duration, options: &JsValue) -> PlainDateTime;
+
+    /// This method computes the difference between the two times represented by zonedDateTime and
+    /// other, optionally rounds it, and returns it as a Temporal.Duration object. If other is earlier
+    /// than zonedDateTime then the resulting duration will be negative. The returned Temporal.Duration, when
+    /// added to zonedDateTime with the same options, will yield other.
+    #[wasm_bindgen(method)]
+    pub fn until(this: &PlainDateTime, other: &PlainDateTime, options: &JsValue) -> Duration;
+
+    /// This method computes the difference between the two times represented by zonedDateTime and
+    /// other, optionally rounds it, and returns it as a Temporal.Duration object. If other is later
+    /// than zonedDateTime then the resulting duration will be negative. The returned Temporal.Duration, when
+    /// added to zonedDateTime with the same options, will yield other.    
+    #[wasm_bindgen(method)]
+    pub fn since(this: &PlainDateTime, other: &PlainDateTime, options: &JsValue) -> Duration;
+
+    /// Returns a new Temporal.PlainDateTime object which is zonedDateTime rounded to `roundTo` (if
+    /// a string parameter is used) or `roundingIncrement` of `smallestUnit` (if an object parameter
+    /// is used).
+    #[wasm_bindgen(method)]
+    pub fn round(this: &PlainDateTime, round_to: &JsValue) -> PlainDateTime;
+
+    #[wasm_bindgen(method)]
+    pub fn equals(this: &PlainDateTime, other: &PlainDateTime) -> bool;
+
+    /// Returns: a plain object with properties expressing zonedDateTime in the ISO 8601 calendar, including
+    /// all date/time fields as well as the calendar, timeZone, and offset properties.
+    ///
+    /// This is an advanced method that's mainly useful if you are implementing a custom calendar. Most
+    /// developers will not need to use it.
+    #[wasm_bindgen(method, js_name = getISOFields)]
+    pub fn get_iso_fields(this: &PlainDateTime) -> JsValue;
+}
+
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(js_namespace = Temporal, extends = Object)]
+    #[derive(Clone, Debug)]
+    pub type ZonedDateTime;
+
+    #[wasm_bindgen(static_method_of = ZonedDateTime, js_namespace = Temporal)]
+    pub fn from(val: &JsValue) -> ZonedDateTime;
+
+    #[wasm_bindgen(static_method_of = ZonedDateTime, js_namespace = Temporal)]
+    pub fn compare(one: &ZonedDateTime, two: &ZonedDateTime) -> i32;
+
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn year(this: &ZonedDateTime) -> i32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn month(this: &ZonedDateTime) -> u32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn week(this: &ZonedDateTime) -> u32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn day(this: &ZonedDateTime) -> u32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn hour(this: &ZonedDateTime) -> u32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn minute(this: &ZonedDateTime) -> u32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn second(this: &ZonedDateTime) -> u32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn millisecond(this: &ZonedDateTime) -> u32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn microsecond(this: &ZonedDateTime) -> u32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn nanosecond(this: &ZonedDateTime) -> u32;
+
+    #[wasm_bindgen(method, getter, structural, js_name = epochSeconds)]
+    pub fn epoch_seconds(this: &ZonedDateTime) -> u64;
+    #[wasm_bindgen(method, getter, structural, js_name = epochMilliseconds)]
+    pub fn epoch_milliseconds(this: &ZonedDateTime) -> u64;
+    #[wasm_bindgen(method, getter, structural, js_name = epochMicroseconds)]
+    pub fn epoch_microseconds(this: &ZonedDateTime) -> BigInt;
+    #[wasm_bindgen(method, getter, structural, js_name = epochNanoseconds)]
+    pub fn epoch_nanoseconds(this: &ZonedDateTime) -> BigInt;
+
+    /// In calendars that use eras, the era and eraYear read-only properties can be used
+    /// together to resolve an era-relative year. Both properties are undefined when using
+    /// the ISO 8601 calendar. As inputs to from or with, era and eraYear can be used instead
+    /// of year. Unlike year, eraYear may decrease as time proceeds because some
+    /// eras (like the BCE era in the Gregorian calendar) count years backwards.
+    #[wasm_bindgen(method, getter, structural, js_name = eraYear)]
+    pub fn era_year(this: &ZonedDateTime) -> JsValue;
+
+    /// In calendars that use eras, the era and eraYear read-only properties can be used
+    /// together to resolve an era-relative year. Both properties are undefined when using
+    /// the ISO 8601 calendar. As inputs to from or with, era and eraYear can be used instead
+    /// of year. Unlike year, eraYear may decrease as time proceeds because some
+    /// eras (like the BCE era in the Gregorian calendar) count years backwards.
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn era(this: &ZonedDateTime) -> JsValue;
+
+    /// The dayOfWeek read-only property gives the weekday number that the date falls
+    /// on. For the ISO 8601 calendar, the weekday number is defined as in the ISO 8601
+    /// standard: a value between 1 and 7, inclusive, with Monday being 1, and Sunday 7.
+    #[wasm_bindgen(method, getter, structural, js_name = dayOfWeek)]
+    pub fn day_of_week(this: &ZonedDateTime) -> u32;
+
+    /// The dayOfYear read-only property gives the ordinal day of the year that the date
+    /// falls on. For the ISO 8601 calendar, this is a value between 1 and 365, or 366 in
+    /// a leap year.
+    #[wasm_bindgen(method, getter, structural, js_name = dayOfYear)]
+    pub fn day_of_year(this: &ZonedDateTime) -> u32;
+
+    /// The weekOfYear read-only property gives the ISO week number of the date. For the
+    /// ISO 8601 calendar, this is normally a value between 1 and 52, but in a few cases it
+    /// can be 53 as well. ISO week 1 is the week containing the first Thursday of the year.
+    #[wasm_bindgen(method, getter, structural, js_name = weekOfYear)]
+    pub fn week_of_year(this: &ZonedDateTime) -> u32;
+
+    /// The daysInWeek read-only property gives the number of days in the week that the
+    /// date falls in. For the ISO 8601 calendar, this is always 7, but in other calendar
+    /// systems it may differ from week to week.
+    #[wasm_bindgen(method, getter, structural, js_name = daysInWeek)]
+    pub fn days_in_week(this: &ZonedDateTime) -> u32;
+
+    /// The daysInMonth read-only property gives the number of days in the month that the
+    /// date falls in. For the ISO 8601 calendar, this is 28, 29, 30, or 31, depending
+    /// on the month and whether the year is a leap year.
+    #[wasm_bindgen(method, getter, structural, js_name = daysInMonth)]
+    pub fn days_in_month(this: &ZonedDateTime) -> u32;
+
+    /// The daysInYear read-only property gives the number of days in the year that the date
+    /// falls in. For the ISO 8601 calendar, this is 365 or 366, depending on whether the year
+    /// is a leap year.
+    #[wasm_bindgen(method, getter, structural, js_name = daysInYear)]
+    pub fn days_in_year(this: &ZonedDateTime) -> u32;
+
+    /// The monthsInYear read-only property gives the number of months in the year that the date
+    /// falls in. For the ISO 8601 calendar, this is always 12, but in other calendar systems
+    /// it may differ from year to year.
+    #[wasm_bindgen(method, getter, structural, js_name = monthsInWeek)]
+    pub fn months_in_year(this: &ZonedDateTime) -> u32;
+
+    /// The inLeapYear read-only property tells whether the year that the date falls in is a
+    /// leap year or not. Its value is true if the year is a leap year, and false if not.
+    #[wasm_bindgen(method, getter, structural, js_name = inLeapYear)]
+    pub fn in_leap_year(this: &ZonedDateTime) -> bool;
+
+    /// The `hoursInDay` read-only property returns the number of real-world hours
+    /// between the start of the current day (usually midnight) in zonedDateTime.timeZone to
+    /// the start of the next calendar day in the same time zone. Normally days will be 24 hours
+    /// long, but on days where there are DST changes or other time zone transitions, this
+    /// property may return 23 or 25. In rare cases, other integers or even non-integer
+    /// values may be returned, e.g. when time zone definitions change by less than one hour.
+    #[wasm_bindgen(method, getter, structural, js_name = inLeapYear)]
+    pub fn hours_in_day(this: &ZonedDateTime) -> u32;
+
+    #[wasm_bindgen(method, getter, structural, js_name = startOfDay)]
+    pub fn start_of_day(this: &ZonedDateTime) -> ZonedDateTime;
+
+    /// The offset read-only property is the offset (formatted as a string) relative
+    /// to UTC of the current time zone and exact instant. Examples: '-08:00' or '+05:30'
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn offset(this: &ZonedDateTime) -> JsString;
+
+    /// This method creates a new Temporal.ZonedDateTime which is a copy of zonedDateTime, but any
+    /// properties present on parameter override the ones already present on zonedDateTime.
+    #[wasm_bindgen(method, js_name = withPlainDate)]
+    pub fn with(this: &ZonedDateTime, parameter: &JsValue, options: &JsValue) -> ZonedDateTime;
+
+    /// Returns a new `Temporal.ZonedDateTime` object which replaces the calendar date of zonedDateTime
+    /// with the calendar date represented by plainDate.
+    #[wasm_bindgen(method, js_name = withPlainDate)]
+    pub fn with_plain_date(this: &ZonedDateTime, date: &PlainDate) -> ZonedDateTime;
+
+    /// Returns a new `Temporal.ZonedDateTime` object which is the date indicated by date, projected
+    /// into calendar.
+    #[wasm_bindgen(method, js_name = withCalendar)]
+    pub fn with_calendar(this: &ZonedDateTime, calendar: &str) -> ZonedDateTime;
+
+    /// This method adds duration to zonedDateTime.
+    #[wasm_bindgen(method)]
+    pub fn add(this: &ZonedDateTime, duration: &Duration, options: &JsValue) -> ZonedDateTime;
+
+    /// This method subtracts duration to zonedDateTime.
+    #[wasm_bindgen(method)]
+    pub fn subtract(this: &ZonedDateTime, duration: &Duration, options: &JsValue) -> ZonedDateTime;
+
+    /// This method computes the difference between the two times represented by zonedDateTime and
+    /// other, optionally rounds it, and returns it as a Temporal.Duration object. If other is earlier
+    /// than zonedDateTime then the resulting duration will be negative. The returned Temporal.Duration, when
+    /// added to zonedDateTime with the same options, will yield other.
+    #[wasm_bindgen(method)]
+    pub fn until(this: &ZonedDateTime, other: &ZonedDateTime, options: &JsValue) -> Duration;
+
+    /// This method computes the difference between the two times represented by zonedDateTime and
+    /// other, optionally rounds it, and returns it as a Temporal.Duration object. If other is later
+    /// than zonedDateTime then the resulting duration will be negative. The returned Temporal.Duration, when
+    /// added to zonedDateTime with the same options, will yield other.    
+    #[wasm_bindgen(method)]
+    pub fn since(this: &ZonedDateTime, other: &ZonedDateTime, options: &JsValue) -> Duration;
+
+    /// Returns a new Temporal.ZonedDateTime object which is zonedDateTime rounded to `roundTo` (if
+    /// a string parameter is used) or `roundingIncrement` of `smallestUnit` (if an object parameter
+    /// is used).
+    #[wasm_bindgen(method)]
+    pub fn round(this: &ZonedDateTime, round_to: &JsValue) -> ZonedDateTime;
+
+    #[wasm_bindgen(method)]
+    pub fn equals(this: &ZonedDateTime, other: &ZonedDateTime) -> bool;
+
+    /// Returns: a plain object with properties expressing zonedDateTime in the ISO 8601 calendar, including
+    /// all date/time fields as well as the calendar, timeZone, and offset properties.
+    ///
+    /// This is an advanced method that's mainly useful if you are implementing a custom calendar. Most
+    /// developers will not need to use it.
+    #[wasm_bindgen(method, js_name = getISOFields)]
+    pub fn get_iso_fields(this: &ZonedDateTime) -> JsValue;
+}
+
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(js_namespace = Temporal, extends = Object)]
+    #[derive(Clone, Debug)]
+    pub type Duration;
+
+    #[wasm_bindgen(static_method_of = Duration, js_namespace = Temporal)]
+    pub fn from(val: &JsValue) -> Duration;
+
+    #[wasm_bindgen(static_method_of = Duration, js_namespace = Temporal)]
+    pub fn compare(one: &Duration, two: &Duration) -> i32;
+
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn years(this: &Duration) -> i32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn months(this: &Duration) -> i32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn weeks(this: &Duration) -> i32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn days(this: &Duration) -> i32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn hours(this: &Duration) -> i32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn minutes(this: &Duration) -> i32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn seconds(this: &Duration) -> i32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn milliseconds(this: &Duration) -> i32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn microseconds(this: &Duration) -> i32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn nanoseconds(this: &Duration) -> i32;
+
+    /// The read-only `sign` property has the value –1, 0, or 1, depending on whether
+    /// the duration is negative, zero, or positive.
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn sign(this: &Duration) -> i32;
+
+    /// The read-only `blank` property is a convenience property that tells whether duration
+    /// represents a zero length of time. In other words, `duration.blank === (duration.sign === 0)`.
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn blank(this: &Duration) -> bool;
+
+    /// In order to be valid, the resulting duration must not have fields with mixed signs, and
+    /// so the result is balanced. For usage examples and a more complete explanation of how
+    /// balancing works and why it is necessary, see [Duration balancing].
+    ///
+    /// [Duration balancing]: https://tc39.es/proposal-temporal/docs/balancing.html
+    #[wasm_bindgen(method)]
+    pub fn add(this: &Duration, other: &Duration, options: &JsValue) -> Duration;
+
+    /// In order to be valid, the resulting duration must not have fields with mixed signs, and
+    /// so the result is balanced. For usage examples and a more complete explanation of how
+    /// balancing works and why it is necessary, see [Duration balancing].
+    ///
+    /// [Duration balancing]: https://tc39.es/proposal-temporal/docs/balancing.html
+    #[wasm_bindgen(method)]
+    pub fn subtract(this: &Duration, other: &Duration, options: &JsValue) -> Duration;
+
+    /// This method gives the absolute value of duration. It returns a newly constructed
+    /// `Temporal.Duration` with all the fields having the same magnitude as those of
+    /// duration, but positive. If duration is already positive or zero, then the returned
+    /// object is a copy of duration.
+    #[wasm_bindgen(method)]
+    pub fn abs(this: &Duration) -> Duration;
+
+    /// Rounds and/or balances duration to the given largest and smallest units and rounding
+    /// increment, and returns the result as a new `Temporal.Duration` object.
+    #[wasm_bindgen(method)]
+    pub fn round(this: &Duration, round_to: &JsValue) -> Duration;
+
+    /// Calculates the number of units of time that can fit in a particular `Temporal.Duration`.
+    /// If the duration IS NOT evenly divisible by the desired unit, then a fractional remainder
+    /// will be present in the result. If the duration IS evenly divisible by the desired
+    /// unit, then the integer result will be identical
+    /// to `duration.round({ smallestUnit: unit, largestUnit: unit, relativeTo })[unit]`
+    #[wasm_bindgen(method)]
+    pub fn total(this: &Duration, total_of: &JsValue) -> f64;
+
+    /// This method overrides `Object.prototype.toString()` and provides the ISO 8601
+    /// description of the duration.
+    #[wasm_bindgen(method, js_name = toString)]
+    pub fn to_string(this: &Duration, options: &JsValue) -> JsString;
+
+    /// This method is the same as duration.toString(). It is usually not called directly, but
+    /// it can be called automatically by JSON.stringify().
+    #[wasm_bindgen(method, js_name = toJson)]
+    pub fn to_json(this: &Duration) -> JsString;
+
+    /// This method overrides `Object.prototype.toLocaleString()` to provide a human-readable,
+    /// language-sensitive representation of duration.
+    ///
+    /// The locales and options arguments are the same as in the constructor to Intl.DurationFormat.
+    #[wasm_bindgen(method, js_name = toLocaleString)]
+    pub fn to_locale_string(this: &Duration, locales: &JsValue, options: &JsValue) -> JsString;
+
+}
+
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(js_namespace = Temporal, extends = Object)]
+    #[derive(Clone, Debug)]
+    pub type PlainTime;
+
+    #[wasm_bindgen(static_method_of = PlainTime, js_namespace = Temporal)]
+    pub fn from(val: &JsValue) -> PlainTime;
+
+    #[wasm_bindgen(static_method_of = PlainTime, js_namespace = Temporal)]
+    pub fn compare(one: &PlainTime, two: &PlainTime) -> i32;
+
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn hour(this: &PlainTime) -> u32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn minute(this: &PlainTime) -> u32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn second(this: &PlainTime) -> u32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn millisecond(this: &PlainTime) -> u32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn microsecond(this: &PlainTime) -> u32;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn nanosecond(this: &PlainTime) -> u32;
+
+    /// This method adds duration to PlainTime.
+    #[wasm_bindgen(method)]
+    pub fn add(this: &PlainTime, duration: &Duration, options: &JsValue) -> PlainTime;
+
+    /// This method subtracts duration to PlainTime.
+    #[wasm_bindgen(method)]
+    pub fn subtract(this: &PlainTime, duration: &Duration, options: &JsValue) -> PlainTime;
+
+    /// This method computes the difference between the two times represented by PlainTime and
+    /// other, optionally rounds it, and returns it as a Temporal.Duration object. If other is earlier
+    /// than zonedDateTime then the resulting duration will be negative. The returned Temporal.Duration, when
+    /// added to zonedDateTime with the same options, will yield other.
+    #[wasm_bindgen(method)]
+    pub fn until(this: &PlainTime, other: &PlainTime, options: &JsValue) -> Duration;
+
+    /// This method computes the difference between the two times represented by PlainTime and
+    /// other, optionally rounds it, and returns it as a Temporal.Duration object. If other is later
+    /// than zonedDateTime then the resulting duration will be negative. The returned Temporal.Duration, when
+    /// added to zonedDateTime with the same options, will yield other.    
+    #[wasm_bindgen(method)]
+    pub fn since(this: &PlainTime, other: &PlainTime, options: &JsValue) -> Duration;
+
+    /// Returns a new Temporal.ZonedDateTime object which is PlainTime rounded to `roundTo` (if
+    /// a string parameter is used) or `roundingIncrement` of `smallestUnit` (if an object parameter
+    /// is used).
+    #[wasm_bindgen(method)]
+    pub fn round(this: &PlainTime, round_to: &JsValue) -> PlainTime;
+
+    #[wasm_bindgen(method)]
+    pub fn equals(this: &PlainTime, other: &PlainTime) -> bool;
+
+    /// This method overrides `Object.prototype.toLocaleString()` to provide a human-readable,
+    /// language-sensitive representation of duration.
+    ///
+    /// The locales and options arguments are the same as in the constructor to Intl.DateTimeFormat.
+    #[wasm_bindgen(method, js_name = toLocaleString)]
+    pub fn to_locale_string(this: &PlainTime, locales: &JsValue, options: &JsValue) -> JsString;
+
+    /// Returns: a plain object with properties expressing PlainTime in the ISO 8601 calendar, including
+    /// all date/time fields as well as the calendar, timeZone, and offset properties.
+    ///
+    /// This is an advanced method that's mainly useful if you are implementing a custom calendar. Most
+    /// developers will not need to use it.
+    #[wasm_bindgen(method, js_name = getISOFields)]
+    pub fn get_iso_fields(this: &PlainTime) -> JsValue;
+
+}
+
+#[wasm_bindgen]
+extern "C" {
+    /// A Temporal.PlainYearMonth represents a particular month on the calendar. For example, it
+    /// could be used to represent a particular instance of a monthly recurring event, like "the
+    /// June 2019 meeting".
+    #[wasm_bindgen(js_namespace = Temporal, extends = Object)]
+    #[derive(Clone, Debug)]
+    pub type PlainYearMonth;
+
+    #[wasm_bindgen(static_method_of = PlainYearMonth, js_namespace = Temporal)]
+    pub fn from(val: &JsValue) -> PlainYearMonth;
+
+    #[wasm_bindgen(static_method_of = PlainYearMonth, js_namespace = Temporal)]
+    pub fn compare(one: &PlainYearMonth, two: &PlainYearMonth) -> i32;
+
+    /// `year` is a signed integer representing the number of years relative to a
+    /// calendar-specific epoch. For calendars that use eras, the anchor is usually
+    /// aligned with the latest era so that eraYear === year for all dates in that
+    /// era. However, some calendars like Japanese may use a different anchor.
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn year(this: &PlainYearMonth) -> i32;
+
+    /// `month` is a positive integer representing the ordinal index of the month in
+    /// the current year. For calendars like Hebrew or Chinese that use leap
+    /// months, the same-named month may have a different month value depending on
+    /// the year. The first month in every year has month equal to 1. The last month
+    /// of every year has month equal to the monthsInYear property. month values
+    /// start at 1, which is different from legacy Date where months are represented
+    /// by zero-based indices (0 to 11).
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn month(this: &PlainYearMonth) -> u32;
+
+    /// `monthCode` is a calendar-specific string that identifies the month in
+    /// a year-independent way. For common (non-leap) months, monthCode should
+    /// be `M${month}`, where month is zero padded up to two digits. For uncommon
+    /// (leap) months in lunisolar calendars like Hebrew or Chinese, the month code
+    /// is the previous month's code with with an "L" suffix appended.
+    /// Examples:
+    /// * 'M02' => February;
+    /// * 'M08L' => repeated 8th month in the Chinese calendar;
+    /// * 'M05L' => Adar I in the Hebrew calendar.
+    #[wasm_bindgen(method, getter, structural, js_name = monthCode)]
+    pub fn month_code(this: &PlainYearMonth) -> JsString;
+
+    /// In calendars that use eras, the era and eraYear read-only properties can be used
+    /// together to resolve an era-relative year. Both properties are undefined when using
+    /// the ISO 8601 calendar. As inputs to from or with, era and eraYear can be used instead
+    /// of year. Unlike year, eraYear may decrease as time proceeds because some
+    /// eras (like the BCE era in the Gregorian calendar) count years backwards.
+    #[wasm_bindgen(method, getter, structural, js_name = eraYear)]
+    pub fn era_year(this: &PlainYearMonth) -> JsValue;
+
+    /// In calendars that use eras, the era and eraYear read-only properties can be used
+    /// together to resolve an era-relative year. Both properties are undefined when using
+    /// the ISO 8601 calendar. As inputs to from or with, era and eraYear can be used instead
+    /// of year. Unlike year, eraYear may decrease as time proceeds because some
+    /// eras (like the BCE era in the Gregorian calendar) count years backwards.
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn era(this: &PlainYearMonth) -> JsValue;
+
+    /// The daysInMonth read-only property gives the number of days in the month that the
+    /// date falls in. For the ISO 8601 calendar, this is 28, 29, 30, or 31, depending
+    /// on the month and whether the year is a leap year.
+    #[wasm_bindgen(method, getter, structural, js_name = daysInMonth)]
+    pub fn days_in_month(this: &PlainYearMonth) -> u32;
+
+    /// The daysInYear read-only property gives the number of days in the year that the date
+    /// falls in. For the ISO 8601 calendar, this is 365 or 366, depending on whether the year
+    /// is a leap year.
+    #[wasm_bindgen(method, getter, structural, js_name = daysInYear)]
+    pub fn days_in_year(this: &PlainYearMonth) -> u32;
+
+    /// The monthsInYear read-only property gives the number of months in the year that the date
+    /// falls in. For the ISO 8601 calendar, this is always 12, but in other calendar systems
+    /// it may differ from year to year.
+    #[wasm_bindgen(method, getter, structural, js_name = monthsInWeek)]
+    pub fn months_in_year(this: &PlainYearMonth) -> u32;
+
+    /// The inLeapYear read-only property tells whether the year that the date falls in is a
+    /// leap year or not. Its value is true if the year is a leap year, and false if not.
+    #[wasm_bindgen(method, getter, structural, js_name = inLeapYear)]
+    pub fn in_leap_year(this: &PlainYearMonth) -> bool;
+
+    /// **Parameters:**
+    ///
+    ///- `duration` (`Temporal.Duration` or value convertible to one): The duration to add.
+    ///- `options` (optional object): An object with properties representing options for the addition.
+    ///The following options are recognized:
+    ///- `overflow` (optional string): How to deal with additions that result in out-of-range values.
+    ///    Allowed values are `constrain` and `reject`.
+    ///    The default is `constrain`.
+    ///
+    ///**Returns:** a new `Temporal.PlainYearMonth` object which is the date indicated by `date` plus `duration`.
+    ///
+    ///This method adds `duration` to `date`, returning a date that is in the future relative to `date`.
+    ///
+    ///The `duration` argument is an object with properties denoting a duration, such as `{ days: 5 }`, or a string such as `P5D`, or a `Temporal.Duration` object.
+    ///If `duration` is not a `Temporal.Duration` object, then it will be converted to one as if it were passed to `Temporal.Duration.from()`.
+    ///
+    ///Some additions may be ambiguous, because months have different lengths.
+    ///For example, adding one month to August 31 would result in September 31, which doesn't exist.
+    ///For these cases, the `overflow` option tells what to do:
+    ///
+    ///- In `constrain` mode (the default), out-of-range values are clamped to the nearest in-range value.
+    ///- In `reject` mode, an addition that would result in an out-of-range value fails, and a `RangeError` is thrown.
+    ///
+    ///Additionally, if the result is earlier or later than the range of dates that `Temporal.PlainYearMonth` can represent (approximately half a million years centered on the [Unix epoch](https://en.wikipedia.org/wiki/Unix_time)), then this method will throw a `RangeError` regardless of `overflow`.
+    ///
+    ///Adding a negative duration is equivalent to subtracting the absolute value of that duration.
+    #[wasm_bindgen(method)]
+    pub fn add(this: &PlainYearMonth, duration: &Duration, options: &JsValue) -> PlainYearMonth;
+
+    /// **Parameters:**
+    ///- `duration` (`Temporal.Duration` or value convertible to one): The duration to subtract.
+    ///- `options` (optional object): An object with properties representing options for the subtraction.
+    ///The following options are recognized:
+    ///- `overflow` (string): How to deal with subtractions that result in out-of-range values.
+    ///    Allowed values are `constrain` and `reject`.
+    ///    The default is `constrain`.
+    ///
+    ///**Returns:** a new `Temporal.PlainYearMonth` object which is the date indicated by `date` minus `duration`.
+    ///
+    ///This method subtracts `duration` from `date`, returning a date that is in the past relative to `date`.
+    ///
+    ///The `duration` argument is an object with properties denoting a duration, such as `{ days: 5 }`, or a string such as `P5D`, or a `Temporal.Duration` object.
+    ///If `duration` is not a `Temporal.Duration` object, then it will be converted to one as if it were passed to `Temporal.Duration.from()`.
+    ///
+    ///Some subtractions may be ambiguous, because months have different lengths.
+    ///For example, subtracting one month from July 31 would result in June 31, which doesn't exist.
+    ///For these cases, the `overflow` option tells what to do:
+    ///
+    ///- In `constrain` mode (the default), out-of-range values are clamped to the nearest in-range value.
+    ///- In `reject` mode, an addition that would result in an out-of-range value fails, and a `RangeError` is thrown.
+    ///
+    ///Additionally, if the result is earlier or later than the range of dates that `Temporal.PlainDate` can represent (approximately half a million years centered on the [Unix epoch](https://en.wikipedia.org/wiki/Unix_time)), then this method will throw a `RangeError` regardless of `overflow`.
+    ///
+    ///Subtracting a negative duration is equivalent to adding the absolute value of that duration.
+    ///
+    #[wasm_bindgen(method)]
+    pub fn subtract(
+        this: &PlainYearMonth,
+        duration: &Duration,
+        options: &JsValue,
+    ) -> PlainYearMonth;
+
+    /// This function exists because it's not possible to compare using date == other
+    /// or date === other, due to ambiguity in the primitive representation and between
+    /// Temporal types.
+    ///
+    /// If you don't need to know the order in which the two dates occur, then this function
+    /// may be less typing and more efficient than Temporal.PlainDate.compare.
+    #[wasm_bindgen(method)]
+    pub fn equals(this: &PlainYearMonth, other: &PlainYearMonth) -> bool;
+
+    /// This method overrides the Object.prototype.toString() method and provides a convenient, unambiguous
+    /// string representation of date. The string can be passed to Temporal.PlainYearMonth.from() to
+    /// create a new Temporal.PlainDate object.
+    #[wasm_bindgen(method, js_name = toString)]
+    pub fn to_string(this: &PlainYearMonth) -> JsString;
+
+    /// This method overrides `Object.prototype.toLocaleString()` to provide a human-readable,
+    /// language-sensitive representation of duration.
+    ///
+    /// The locales and options arguments are the same as in the constructor to Intl.DateTimeFormat.
+    #[wasm_bindgen(method, js_name = toLocaleString)]
+    pub fn to_locale_string(
+        this: &PlainYearMonth,
+        locales: &JsValue,
+        options: &JsValue,
+    ) -> JsString;
+
+    /// Returns: a plain object with properties expressing date in the ISO 8601
+    /// calendar, as well as the value of date.calendar.
+    ///
+    /// This method is mainly useful if you are implementing a custom calendar. Most
+    /// code will not need to use it.
+    #[wasm_bindgen(method, js_name = getISOFields)]
+    pub fn get_iso_fields(this: &PlainYearMonth) -> JsValue;
+
+}
+
+#[wasm_bindgen]
+extern "C" {
+    /// A date without a year component. This is useful to express
+    /// things like "Bastille Day is on the 14th of July".
+    #[wasm_bindgen(js_namespace = Temporal, extends = Object)]
+    #[derive(Clone, Debug)]
+    pub type PlainMonthDay;
+
+    #[wasm_bindgen(static_method_of = PlainMonthDay, js_namespace = Temporal)]
+    pub fn from(val: &JsValue) -> PlainMonthDay;
+
+    #[wasm_bindgen(static_method_of = PlainMonthDay, js_namespace = Temporal)]
+    pub fn compare(one: &PlainMonthDay, two: &PlainMonthDay) -> i32;
+
+    /// `monthCode` is a calendar-specific string that identifies the month in
+    /// a year-independent way. For common (non-leap) months, monthCode should
+    /// be `M${month}`, where month is zero padded up to two digits. For uncommon
+    /// (leap) months in lunisolar calendars like Hebrew or Chinese, the month code
+    /// is the previous month's code with with an "L" suffix appended.
+    /// Examples:
+    /// * 'M02' => February;
+    /// * 'M08L' => repeated 8th month in the Chinese calendar;
+    /// * 'M05L' => Adar I in the Hebrew calendar.
+    ///
+    /// Note that this type has no month property, because month is ambiguous for some
+    /// calendars without knowing the year. Instead, the monthCode property is used which
+    /// is year-independent in all calendars.
+    #[wasm_bindgen(method, getter, structural, js_name = monthCode)]
+    pub fn month_code(this: &PlainMonthDay) -> JsString;
+
+    /// day is a positive integer representing the day of the month.
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn day(this: &PlainMonthDay) -> u32;
+
+    /// This function exists because it's not possible to compare using date == other
+    /// or date === other, due to ambiguity in the primitive representation and between
+    /// Temporal types.
+    ///
+    /// If you don't need to know the order in which the two dates occur, then this function
+    /// may be less typing and more efficient than Temporal.PlainMonthDay.compare.
+    ///
+    /// Note that this function will return false if the two objects have different calendar
+    /// properties, even if the actual dates are equal.
+    #[wasm_bindgen(method)]
+    pub fn equals(this: &PlainMonthDay, other: &PlainMonthDay) -> bool;
+
+    /// This method overrides the Object.prototype.toString() method and provides a convenient, unambiguous
+    /// string representation of date. The string can be passed to Temporal.PlainMonthDay.from() to
+    /// create a new Temporal.PlainMonthDay object.
+    #[wasm_bindgen(method, js_name = toString)]
+    pub fn to_string(this: &PlainMonthDay) -> JsString;
+
+    /// This method overrides `Object.prototype.toLocaleString()` to provide a human-readable,
+    /// language-sensitive representation of duration.
+    ///
+    /// The locales and options arguments are the same as in the constructor to Intl.DateTimeFormat.
+    #[wasm_bindgen(method, js_name = toLocaleString)]
+    pub fn to_locale_string(this: &PlainMonthDay, locales: &JsValue, options: &JsValue)
+        -> JsString;
+
+    /// Returns: a plain object with properties expressing date in the ISO 8601
+    /// calendar, as well as the value of date.calendar.
+    ///
+    /// This method is mainly useful if you are implementing a custom calendar. Most
+    /// code will not need to use it.
+    #[wasm_bindgen(method, js_name = getISOFields)]
+    pub fn get_iso_fields(this: &PlainMonthDay) -> JsValue;
+
+}
+
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(js_namespace = Temporal, extends = Object)]
+    #[derive(Clone, Debug)]
+    pub type PlainDate;
+
+    #[wasm_bindgen(js_namespace = Temporal, constructor)]
+    pub fn new(year: i32, month: u32, day: u32) -> PlainDate;
+
+    #[wasm_bindgen(static_method_of = PlainDate, js_namespace = Temporal)]
+    pub fn from(val: &JsValue) -> PlainDate;
+
+    #[wasm_bindgen(static_method_of = PlainDate, js_namespace = Temporal)]
+    pub fn compare(one: &PlainDate, two: &PlainDate) -> i32;
+
+    /// `year` is a signed integer representing the number of years relative to a
+    /// calendar-specific epoch. For calendars that use eras, the anchor is usually
+    /// aligned with the latest era so that eraYear === year for all dates in that
+    /// era. However, some calendars like Japanese may use a different anchor.
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn year(this: &PlainDate) -> i32;
+
+    /// `month` is a positive integer representing the ordinal index of the month in
+    /// the current year. For calendars like Hebrew or Chinese that use leap
+    /// months, the same-named month may have a different month value depending on
+    /// the year. The first month in every year has month equal to 1. The last month
+    /// of every year has month equal to the monthsInYear property. month values
+    /// start at 1, which is different from legacy Date where months are represented
+    /// by zero-based indices (0 to 11).
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn month(this: &PlainDate) -> u32;
+
+    /// `monthCode` is a calendar-specific string that identifies the month in
+    /// a year-independent way. For common (non-leap) months, monthCode should
+    /// be `M${month}`, where month is zero padded up to two digits. For uncommon
+    /// (leap) months in lunisolar calendars like Hebrew or Chinese, the month code
+    /// is the previous month's code with with an "L" suffix appended.
+    /// Examples:
+    /// * 'M02' => February;
+    /// * 'M08L' => repeated 8th month in the Chinese calendar;
+    /// * 'M05L' => Adar I in the Hebrew calendar.
+    #[wasm_bindgen(method, getter, structural, js_name = monthCode)]
+    pub fn month_code(this: &PlainDate) -> JsString;
+
+    /// day is a positive integer representing the day of the month.
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn day(this: &PlainDate) -> u32;
+
+    /// In calendars that use eras, the era and eraYear read-only properties can be used
+    /// together to resolve an era-relative year. Both properties are undefined when using
+    /// the ISO 8601 calendar. As inputs to from or with, era and eraYear can be used instead
+    /// of year. Unlike year, eraYear may decrease as time proceeds because some
+    /// eras (like the BCE era in the Gregorian calendar) count years backwards.
+    #[wasm_bindgen(method, getter, structural, js_name = eraYear)]
+    pub fn era_year(this: &PlainDate) -> JsValue;
+
+    /// In calendars that use eras, the era and eraYear read-only properties can be used
+    /// together to resolve an era-relative year. Both properties are undefined when using
+    /// the ISO 8601 calendar. As inputs to from or with, era and eraYear can be used instead
+    /// of year. Unlike year, eraYear may decrease as time proceeds because some
+    /// eras (like the BCE era in the Gregorian calendar) count years backwards.
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn era(this: &PlainDate) -> JsValue;
+
+    /// The dayOfWeek read-only property gives the weekday number that the date falls
+    /// on. For the ISO 8601 calendar, the weekday number is defined as in the ISO 8601
+    /// standard: a value between 1 and 7, inclusive, with Monday being 1, and Sunday 7.
+    #[wasm_bindgen(method, getter, structural, js_name = dayOfWeek)]
+    pub fn day_of_week(this: &PlainDate) -> u32;
+
+    /// The dayOfYear read-only property gives the ordinal day of the year that the date
+    /// falls on. For the ISO 8601 calendar, this is a value between 1 and 365, or 366 in
+    /// a leap year.
+    #[wasm_bindgen(method, getter, structural, js_name = dayOfYear)]
+    pub fn day_of_year(this: &PlainDate) -> u32;
+
+    /// The weekOfYear read-only property gives the ISO week number of the date. For the
+    /// ISO 8601 calendar, this is normally a value between 1 and 52, but in a few cases it
+    /// can be 53 as well. ISO week 1 is the week containing the first Thursday of the year.
+    #[wasm_bindgen(method, getter, structural, js_name = weekOfYear)]
+    pub fn week_of_year(this: &PlainDate) -> u32;
+
+    /// The daysInWeek read-only property gives the number of days in the week that the
+    /// date falls in. For the ISO 8601 calendar, this is always 7, but in other calendar
+    /// systems it may differ from week to week.
+    #[wasm_bindgen(method, getter, structural, js_name = daysInWeek)]
+    pub fn days_in_week(this: &PlainDate) -> u32;
+
+    /// The daysInMonth read-only property gives the number of days in the month that the
+    /// date falls in. For the ISO 8601 calendar, this is 28, 29, 30, or 31, depending
+    /// on the month and whether the year is a leap year.
+    #[wasm_bindgen(method, getter, structural, js_name = daysInMonth)]
+    pub fn days_in_month(this: &PlainDate) -> u32;
+
+    /// The daysInYear read-only property gives the number of days in the year that the date
+    /// falls in. For the ISO 8601 calendar, this is 365 or 366, depending on whether the year
+    /// is a leap year.
+    #[wasm_bindgen(method, getter, structural, js_name = daysInYear)]
+    pub fn days_in_year(this: &PlainDate) -> u32;
+
+    /// The monthsInYear read-only property gives the number of months in the year that the date
+    /// falls in. For the ISO 8601 calendar, this is always 12, but in other calendar systems
+    /// it may differ from year to year.
+    #[wasm_bindgen(method, getter, structural, js_name = monthsInWeek)]
+    pub fn months_in_year(this: &PlainDate) -> u32;
+
+    /// The inLeapYear read-only property tells whether the year that the date falls in is a
+    /// leap year or not. Its value is true if the year is a leap year, and false if not.
+    #[wasm_bindgen(method, getter, structural, js_name = inLeapYear)]
+    pub fn in_leap_year(this: &PlainDate) -> bool;
+
+    /// Returns a new `Temporal.PlainDate` object which is the date indicated by date, projected
+    /// into calendar.
+    #[wasm_bindgen(method, js_name = withCalendar)]
+    pub fn with_calendar(this: &PlainDate, calendar: &str) -> PlainDate;
+
+    /// **Parameters:**
+    ///
+    ///- `duration` (`Temporal.Duration` or value convertible to one): The duration to add.
+    ///- `options` (optional object): An object with properties representing options for the addition.
+    ///The following options are recognized:
+    ///- `overflow` (optional string): How to deal with additions that result in out-of-range values.
+    ///    Allowed values are `constrain` and `reject`.
+    ///    The default is `constrain`.
+    ///
+    ///**Returns:** a new `Temporal.PlainDate` object which is the date indicated by `date` plus `duration`.
+    ///
+    ///This method adds `duration` to `date`, returning a date that is in the future relative to `date`.
+    ///
+    ///The `duration` argument is an object with properties denoting a duration, such as `{ days: 5 }`, or a string such as `P5D`, or a `Temporal.Duration` object.
+    ///If `duration` is not a `Temporal.Duration` object, then it will be converted to one as if it were passed to `Temporal.Duration.from()`.
+    ///
+    ///Some additions may be ambiguous, because months have different lengths.
+    ///For example, adding one month to August 31 would result in September 31, which doesn't exist.
+    ///For these cases, the `overflow` option tells what to do:
+    ///
+    ///- In `constrain` mode (the default), out-of-range values are clamped to the nearest in-range value.
+    ///- In `reject` mode, an addition that would result in an out-of-range value fails, and a `RangeError` is thrown.
+    ///
+    ///Additionally, if the result is earlier or later than the range of dates that `Temporal.PlainDate` can represent (approximately half a million years centered on the [Unix epoch](https://en.wikipedia.org/wiki/Unix_time)), then this method will throw a `RangeError` regardless of `overflow`.
+    ///
+    ///Adding a negative duration is equivalent to subtracting the absolute value of that duration.
+    #[wasm_bindgen(method)]
+    pub fn add(this: &PlainDate, duration: &Duration, options: &JsValue) -> PlainDate;
+
+    /// **Parameters:**
+    ///- `duration` (`Temporal.Duration` or value convertible to one): The duration to subtract.
+    ///- `options` (optional object): An object with properties representing options for the subtraction.
+    ///The following options are recognized:
+    ///- `overflow` (string): How to deal with subtractions that result in out-of-range values.
+    ///    Allowed values are `constrain` and `reject`.
+    ///    The default is `constrain`.
+    ///
+    ///**Returns:** a new `Temporal.PlainDate` object which is the date indicated by `date` minus `duration`.
+    ///
+    ///This method subtracts `duration` from `date`, returning a date that is in the past relative to `date`.
+    ///
+    ///The `duration` argument is an object with properties denoting a duration, such as `{ days: 5 }`, or a string such as `P5D`, or a `Temporal.Duration` object.
+    ///If `duration` is not a `Temporal.Duration` object, then it will be converted to one as if it were passed to `Temporal.Duration.from()`.
+    ///
+    ///Some subtractions may be ambiguous, because months have different lengths.
+    ///For example, subtracting one month from July 31 would result in June 31, which doesn't exist.
+    ///For these cases, the `overflow` option tells what to do:
+    ///
+    ///- In `constrain` mode (the default), out-of-range values are clamped to the nearest in-range value.
+    ///- In `reject` mode, an addition that would result in an out-of-range value fails, and a `RangeError` is thrown.
+    ///
+    ///Additionally, if the result is earlier or later than the range of dates that `Temporal.PlainDate` can represent (approximately half a million years centered on the [Unix epoch](https://en.wikipedia.org/wiki/Unix_time)), then this method will throw a `RangeError` regardless of `overflow`.
+    ///
+    ///Subtracting a negative duration is equivalent to adding the absolute value of that duration.
+    ///
+    #[wasm_bindgen(method)]
+    pub fn subtract(this: &PlainDate, duration: &Duration, options: &JsValue) -> PlainDate;
+
+    /// This function exists because it's not possible to compare using date == other
+    /// or date === other, due to ambiguity in the primitive representation and between
+    /// Temporal types.
+    ///
+    /// If you don't need to know the order in which the two dates occur, then this function
+    /// may be less typing and more efficient than Temporal.PlainDate.compare.
+    ///
+    /// Note that this function will return false if the two objects have different calendar
+    /// properties, even if the actual dates are equal.
+    #[wasm_bindgen(method)]
+    pub fn equals(this: &PlainDate, other: &PlainDate) -> bool;
+
+    /// This method overrides the Object.prototype.toString() method and provides a convenient, unambiguous
+    /// string representation of date. The string can be passed to Temporal.PlainDate.from() to
+    /// create a new Temporal.PlainDate object.
+    #[wasm_bindgen(method, js_name = toString)]
+    pub fn to_string(this: &PlainDate) -> JsString;
+
+    /// This method overrides `Object.prototype.toLocaleString()` to provide a human-readable,
+    /// language-sensitive representation of duration.
+    ///
+    /// The locales and options arguments are the same as in the constructor to Intl.DateTimeFormat.
+    #[wasm_bindgen(method, js_name = toLocaleString)]
+    pub fn to_locale_string(this: &PlainDate, locales: &JsValue, options: &JsValue) -> JsString;
+
+    /// Returns: a plain object with properties expressing date in the ISO 8601
+    /// calendar, as well as the value of date.calendar.
+    ///
+    /// This method is mainly useful if you are implementing a custom calendar. Most
+    /// code will not need to use it.
+    #[wasm_bindgen(method, js_name = getISOFields)]
+    pub fn get_iso_fields(this: &PlainDate) -> JsValue;
+
+}
+
+pub mod Now {
+    use super::*;
+
+    #[wasm_bindgen]
+    extern "C" {
+        #[wasm_bindgen(js_namespace = ["Temporal", "Now"])]
+        pub fn instant() -> Instant;
+
+        #[wasm_bindgen(js_namespace = ["Temporal", "Now"], js_name = zonedDateTime)]
+        pub fn zoned_date_time(calendar: &str) -> ZonedDateTime;
+
+        #[wasm_bindgen(js_namespace = ["Temporal", "Now"], js_name = zonedDateTimeISO)]
+        pub fn zoned_date_time_iso() -> ZonedDateTime;
+
+        #[wasm_bindgen(js_namespace = ["Temporal", "Now"], js_name = plainDate)]
+        pub fn plain_date(calendar: &str) -> PlainDate;
+
+        #[wasm_bindgen(js_namespace = ["Temporal", "Now"], js_name = plainDateISO)]
+        pub fn plain_date_iso() -> PlainDate;
+
+        #[wasm_bindgen(js_namespace = ["Temporal", "Now"], js_name = plainTimeISO)]
+        pub fn plain_time_iso() -> PlainTime;
+
+    }
+}
diff --git a/vendor/js-sys/src/lib.rs b/vendor/js-sys/src/lib.rs
new file mode 100644
index 000000000..12fef1cb7
--- /dev/null
+++ b/vendor/js-sys/src/lib.rs
@@ -0,0 +1,5871 @@
+//! Bindings to JavaScript's standard, built-in objects, including their methods
+//! and properties.
+//!
+//! This does *not* include any Web, Node, or any other JS environment
+//! APIs. Only the things that are guaranteed to exist in the global scope by
+//! the ECMAScript standard.
+//!
+//! <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects>
+//!
+//! ## A Note About `camelCase`, `snake_case`, and Naming Conventions
+//!
+//! JavaScript's global objects use `camelCase` naming conventions for functions
+//! and methods, but Rust style is to use `snake_case`. These bindings expose
+//! the Rust style `snake_case` name. Additionally, acronyms within a method
+//! name are all lower case, where as in JavaScript they are all upper case. For
+//! example, `decodeURI` in JavaScript is exposed as `decode_uri` in these
+//! bindings.
+
+#![doc(html_root_url = "https://docs.rs/js-sys/0.2")]
+
+use core::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Neg, Not, Rem, Shl, Shr, Sub};
+use std::cmp::Ordering;
+use std::convert::{self, Infallible, TryFrom};
+use std::f64;
+use std::fmt;
+use std::iter::{self, Product, Sum};
+use std::mem;
+use std::str;
+use std::str::FromStr;
+
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+
+// When adding new imports:
+//
+// * Keep imports in alphabetical order.
+//
+// * Rename imports with `js_name = ...` according to the note about `camelCase`
+//   and `snake_case` in the module's documentation above.
+//
+// * Include the one sentence summary of the import from the MDN link in the
+//   module's documentation above, and the MDN link itself.
+//
+// * If a function or method can throw an exception, make it catchable by adding
+//   `#[wasm_bindgen(catch)]`.
+//
+// * Add a new `#[test]` into the appropriate file in the
+//   `crates/js-sys/tests/wasm/` directory. If the imported function or method
+//   can throw an exception, make sure to also add test coverage for that case.
+//
+// * Arguments that are `JsValue`s or imported JavaScript types should be taken
+//   by reference.
+
+macro_rules! forward_deref_unop {
+    (impl $imp:ident, $method:ident for $t:ty) => {
+        impl $imp for $t {
+            type Output = <&'static $t as $imp>::Output;
+
+            #[inline]
+            fn $method(self) -> Self::Output {
+                $imp::$method(&self)
+            }
+        }
+    };
+}
+
+macro_rules! forward_deref_binop {
+    (impl $imp:ident, $method:ident for $t:ty) => {
+        impl<'a> $imp<$t> for &'a $t {
+            type Output = <&'static $t as $imp<&'static $t>>::Output;
+
+            #[inline]
+            fn $method(self, other: $t) -> Self::Output {
+                $imp::$method(self, &other)
+            }
+        }
+
+        impl $imp<&$t> for $t {
+            type Output = <&'static $t as $imp<&'static $t>>::Output;
+
+            #[inline]
+            fn $method(self, other: &$t) -> Self::Output {
+                $imp::$method(&self, other)
+            }
+        }
+
+        impl $imp<$t> for $t {
+            type Output = <&'static $t as $imp<&'static $t>>::Output;
+
+            #[inline]
+            fn $method(self, other: $t) -> Self::Output {
+                $imp::$method(&self, &other)
+            }
+        }
+    };
+}
+
+macro_rules! forward_js_unop {
+    (impl $imp:ident, $method:ident for $t:ty) => {
+        impl $imp for &$t {
+            type Output = $t;
+
+            #[inline]
+            fn $method(self) -> Self::Output {
+                $imp::$method(JsValue::as_ref(self)).unchecked_into()
+            }
+        }
+
+        forward_deref_unop!(impl $imp, $method for $t);
+    };
+}
+
+macro_rules! forward_js_binop {
+    (impl $imp:ident, $method:ident for $t:ty) => {
+        impl $imp<&$t> for &$t {
+            type Output = $t;
+
+            #[inline]
+            fn $method(self, other: &$t) -> Self::Output {
+                $imp::$method(JsValue::as_ref(self), JsValue::as_ref(other)).unchecked_into()
+            }
+        }
+
+        forward_deref_binop!(impl $imp, $method for $t);
+    };
+}
+
+macro_rules! sum_product {
+    ($($a:ident)*) => ($(
+        impl Sum for $a {
+            #[inline]
+            fn sum<I: iter::Iterator<Item=Self>>(iter: I) -> Self {
+                iter.fold(
+                    $a::from(0),
+                    |a, b| a + b,
+                )
+            }
+        }
+
+        impl Product for $a {
+            #[inline]
+            fn product<I: iter::Iterator<Item=Self>>(iter: I) -> Self {
+                iter.fold(
+                    $a::from(1),
+                    |a, b| a * b,
+                )
+            }
+        }
+
+        impl<'a> Sum<&'a $a> for $a {
+            fn sum<I: iter::Iterator<Item=&'a Self>>(iter: I) -> Self {
+                iter.fold(
+                    $a::from(0),
+                    |a, b| a + b,
+                )
+            }
+        }
+
+        impl<'a> Product<&'a $a> for $a {
+            #[inline]
+            fn product<I: iter::Iterator<Item=&'a Self>>(iter: I) -> Self {
+                iter.fold(
+                    $a::from(1),
+                    |a, b| a * b,
+                )
+            }
+        }
+    )*)
+}
+
+macro_rules! partialord_ord {
+    ($t:ident) => {
+        impl PartialOrd for $t {
+            #[inline]
+            fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+                Some(self.cmp(other))
+            }
+
+            #[inline]
+            fn lt(&self, other: &Self) -> bool {
+                JsValue::as_ref(self).lt(JsValue::as_ref(other))
+            }
+
+            #[inline]
+            fn le(&self, other: &Self) -> bool {
+                JsValue::as_ref(self).le(JsValue::as_ref(other))
+            }
+
+            #[inline]
+            fn ge(&self, other: &Self) -> bool {
+                JsValue::as_ref(self).ge(JsValue::as_ref(other))
+            }
+
+            #[inline]
+            fn gt(&self, other: &Self) -> bool {
+                JsValue::as_ref(self).gt(JsValue::as_ref(other))
+            }
+        }
+
+        impl Ord for $t {
+            #[inline]
+            fn cmp(&self, other: &Self) -> Ordering {
+                if self == other {
+                    Ordering::Equal
+                } else if self.lt(other) {
+                    Ordering::Less
+                } else {
+                    Ordering::Greater
+                }
+            }
+        }
+    };
+}
+
+#[wasm_bindgen]
+extern "C" {
+    /// The `decodeURI()` function decodes a Uniform Resource Identifier (URI)
+    /// previously created by `encodeURI` or by a similar routine.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURI)
+    #[wasm_bindgen(catch, js_name = decodeURI)]
+    pub fn decode_uri(encoded: &str) -> Result<JsString, JsValue>;
+
+    /// The `decodeURIComponent()` function decodes a Uniform Resource Identifier (URI) component
+    /// previously created by `encodeURIComponent` or by a similar routine.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent)
+    #[wasm_bindgen(catch, js_name = decodeURIComponent)]
+    pub fn decode_uri_component(encoded: &str) -> Result<JsString, JsValue>;
+
+    /// The `encodeURI()` function encodes a Uniform Resource Identifier (URI)
+    /// by replacing each instance of certain characters by one, two, three, or
+    /// four escape sequences representing the UTF-8 encoding of the character
+    /// (will only be four escape sequences for characters composed of two
+    /// "surrogate" characters).
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURI)
+    #[wasm_bindgen(js_name = encodeURI)]
+    pub fn encode_uri(decoded: &str) -> JsString;
+
+    /// The `encodeURIComponent()` function encodes a Uniform Resource Identifier (URI) component
+    /// by replacing each instance of certain characters by one, two, three, or four escape sequences
+    /// representing the UTF-8 encoding of the character
+    /// (will only be four escape sequences for characters composed of two "surrogate" characters).
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent)
+    #[wasm_bindgen(js_name = encodeURIComponent)]
+    pub fn encode_uri_component(decoded: &str) -> JsString;
+
+    /// The `eval()` function evaluates JavaScript code represented as a string.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval)
+    #[wasm_bindgen(catch)]
+    pub fn eval(js_source_text: &str) -> Result<JsValue, JsValue>;
+
+    /// The global `isFinite()` function determines whether the passed value is a finite number.
+    /// If needed, the parameter is first converted to a number.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/isFinite)
+    #[wasm_bindgen(js_name = isFinite)]
+    pub fn is_finite(value: &JsValue) -> bool;
+
+    /// The `parseInt()` function parses a string argument and returns an integer
+    /// of the specified radix (the base in mathematical numeral systems), or NaN on error.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt)
+    #[wasm_bindgen(js_name = parseInt)]
+    pub fn parse_int(text: &str, radix: u8) -> f64;
+
+    /// The `parseFloat()` function parses an argument and returns a floating point number,
+    /// or NaN on error.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseFloat)
+    #[wasm_bindgen(js_name = parseFloat)]
+    pub fn parse_float(text: &str) -> f64;
+
+    /// The `escape()` function computes a new string in which certain characters have been
+    /// replaced by a hexadecimal escape sequence.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/escape)
+    #[wasm_bindgen]
+    pub fn escape(string: &str) -> JsString;
+
+    /// The `unescape()` function computes a new string in which hexadecimal escape
+    /// sequences are replaced with the character that it represents. The escape sequences might
+    /// be introduced by a function like `escape`. Usually, `decodeURI` or `decodeURIComponent`
+    /// are preferred over `unescape`.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/unescape)
+    #[wasm_bindgen]
+    pub fn unescape(string: &str) -> JsString;
+}
+
+// Array
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(extends = Object, is_type_of = Array::is_array, typescript_type = "Array<any>")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type Array;
+
+    /// Creates a new empty array.
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Array;
+
+    /// Creates a new array with the specified length (elements are initialized to `undefined`).
+    #[wasm_bindgen(constructor)]
+    pub fn new_with_length(len: u32) -> Array;
+
+    /// Retrieves the element at the index, counting from the end if negative
+    /// (returns `undefined` if the index is out of range).
+    #[wasm_bindgen(method)]
+    pub fn at(this: &Array, index: i32) -> JsValue;
+
+    /// Retrieves the element at the index (returns `undefined` if the index is out of range).
+    #[wasm_bindgen(method, structural, indexing_getter)]
+    pub fn get(this: &Array, index: u32) -> JsValue;
+
+    /// Sets the element at the index (auto-enlarges the array if the index is out of range).
+    #[wasm_bindgen(method, structural, indexing_setter)]
+    pub fn set(this: &Array, index: u32, value: JsValue);
+
+    /// Deletes the element at the index (does nothing if the index is out of range).
+    ///
+    /// The element at the index is set to `undefined`.
+    ///
+    /// This does not resize the array, the array will still be the same length.
+    #[wasm_bindgen(method, structural, indexing_deleter)]
+    pub fn delete(this: &Array, index: u32);
+
+    /// The `Array.from()` method creates a new, shallow-copied `Array` instance
+    /// from an array-like or iterable object.
+    #[wasm_bindgen(static_method_of = Array)]
+    pub fn from(val: &JsValue) -> Array;
+
+    /// The `copyWithin()` method shallow copies part of an array to another
+    /// location in the same array and returns it, without modifying its size.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin)
+    #[wasm_bindgen(method, js_name = copyWithin)]
+    pub fn copy_within(this: &Array, target: i32, start: i32, end: i32) -> Array;
+
+    /// The `concat()` method is used to merge two or more arrays. This method
+    /// does not change the existing arrays, but instead returns a new array.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat)
+    #[wasm_bindgen(method)]
+    pub fn concat(this: &Array, array: &Array) -> Array;
+
+    /// The `every()` method tests whether all elements in the array pass the test
+    /// implemented by the provided function.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every)
+    #[wasm_bindgen(method)]
+    pub fn every(this: &Array, predicate: &mut dyn FnMut(JsValue, u32, Array) -> bool) -> bool;
+
+    /// The `fill()` method fills all the elements of an array from a start index
+    /// to an end index with a static value. The end index is not included.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill)
+    #[wasm_bindgen(method)]
+    pub fn fill(this: &Array, value: &JsValue, start: u32, end: u32) -> Array;
+
+    /// The `filter()` method creates a new array with all elements that pass the
+    /// test implemented by the provided function.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)
+    #[wasm_bindgen(method)]
+    pub fn filter(this: &Array, predicate: &mut dyn FnMut(JsValue, u32, Array) -> bool) -> Array;
+
+    /// The `find()` method returns the value of the first element in the array that satisfies
+    ///  the provided testing function. Otherwise `undefined` is returned.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)
+    #[wasm_bindgen(method)]
+    pub fn find(this: &Array, predicate: &mut dyn FnMut(JsValue, u32, Array) -> bool) -> JsValue;
+
+    /// The `findIndex()` method returns the index of the first element in the array that
+    /// satisfies the provided testing function. Otherwise -1 is returned.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex)
+    #[wasm_bindgen(method, js_name = findIndex)]
+    pub fn find_index(this: &Array, predicate: &mut dyn FnMut(JsValue, u32, Array) -> bool) -> i32;
+
+    /// The `flat()` method creates a new array with all sub-array elements concatenated into it
+    /// recursively up to the specified depth.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat)
+    #[wasm_bindgen(method)]
+    pub fn flat(this: &Array, depth: i32) -> Array;
+
+    /// The `flatMap()` method first maps each element using a mapping function, then flattens
+    /// the result into a new array.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flatMap)
+    #[wasm_bindgen(method, js_name = flatMap)]
+    pub fn flat_map(
+        this: &Array,
+        callback: &mut dyn FnMut(JsValue, u32, Array) -> Vec<JsValue>,
+    ) -> Array;
+
+    /// The `forEach()` method executes a provided function once for each array element.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)
+    #[wasm_bindgen(method, js_name = forEach)]
+    pub fn for_each(this: &Array, callback: &mut dyn FnMut(JsValue, u32, Array));
+
+    /// The `includes()` method determines whether an array includes a certain
+    /// element, returning true or false as appropriate.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes)
+    #[wasm_bindgen(method)]
+    pub fn includes(this: &Array, value: &JsValue, from_index: i32) -> bool;
+
+    /// The `indexOf()` method returns the first index at which a given element
+    /// can be found in the array, or -1 if it is not present.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf)
+    #[wasm_bindgen(method, js_name = indexOf)]
+    pub fn index_of(this: &Array, value: &JsValue, from_index: i32) -> i32;
+
+    /// The `Array.isArray()` method determines whether the passed value is an Array.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray)
+    #[wasm_bindgen(static_method_of = Array, js_name = isArray)]
+    pub fn is_array(value: &JsValue) -> bool;
+
+    /// The `join()` method joins all elements of an array (or an array-like object)
+    /// into a string and returns this string.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join)
+    #[wasm_bindgen(method)]
+    pub fn join(this: &Array, delimiter: &str) -> JsString;
+
+    /// The `lastIndexOf()` method returns the last index at which a given element
+    /// can be found in the array, or -1 if it is not present. The array is
+    /// searched backwards, starting at fromIndex.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf)
+    #[wasm_bindgen(method, js_name = lastIndexOf)]
+    pub fn last_index_of(this: &Array, value: &JsValue, from_index: i32) -> i32;
+
+    /// The length property of an object which is an instance of type Array
+    /// sets or returns the number of elements in that array. The value is an
+    /// unsigned, 32-bit integer that is always numerically greater than the
+    /// highest index in the array.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/length)
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn length(this: &Array) -> u32;
+
+    /// `map()` calls a provided callback function once for each element in an array,
+    /// in order, and constructs a new array from the results. callback is invoked
+    /// only for indexes of the array which have assigned values, including undefined.
+    /// It is not called for missing elements of the array (that is, indexes that have
+    /// never been set, which have been deleted or which have never been assigned a value).
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)
+    #[wasm_bindgen(method)]
+    pub fn map(this: &Array, predicate: &mut dyn FnMut(JsValue, u32, Array) -> JsValue) -> Array;
+
+    /// The `Array.of()` method creates a new Array instance with a variable
+    /// number of arguments, regardless of number or type of the arguments.
+    ///
+    /// The difference between `Array.of()` and the `Array` constructor is in the
+    /// handling of integer arguments: `Array.of(7)` creates an array with a single
+    /// element, `7`, whereas `Array(7)` creates an empty array with a `length`
+    /// property of `7` (Note: this implies an array of 7 empty slots, not slots
+    /// with actual undefined values).
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of)
+    ///
+    /// # Notes
+    ///
+    /// There are a few bindings to `of` in `js-sys`: `of1`, `of2`, etc...
+    /// with different arities.
+    #[wasm_bindgen(static_method_of = Array, js_name = of)]
+    pub fn of1(a: &JsValue) -> Array;
+
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of)
+    #[wasm_bindgen(static_method_of = Array, js_name = of)]
+    pub fn of2(a: &JsValue, b: &JsValue) -> Array;
+
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of)
+    #[wasm_bindgen(static_method_of = Array, js_name = of)]
+    pub fn of3(a: &JsValue, b: &JsValue, c: &JsValue) -> Array;
+
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of)
+    #[wasm_bindgen(static_method_of = Array, js_name = of)]
+    pub fn of4(a: &JsValue, b: &JsValue, c: &JsValue, d: &JsValue) -> Array;
+
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of)
+    #[wasm_bindgen(static_method_of = Array, js_name = of)]
+    pub fn of5(a: &JsValue, b: &JsValue, c: &JsValue, d: &JsValue, e: &JsValue) -> Array;
+
+    /// The `pop()` method removes the last element from an array and returns that
+    /// element. This method changes the length of the array.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop)
+    #[wasm_bindgen(method)]
+    pub fn pop(this: &Array) -> JsValue;
+
+    /// The `push()` method adds one or more elements to the end of an array and
+    /// returns the new length of the array.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push)
+    #[wasm_bindgen(method)]
+    pub fn push(this: &Array, value: &JsValue) -> u32;
+
+    /// The `reduce()` method applies a function against an accumulator and each element in
+    /// the array (from left to right) to reduce it to a single value.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce)
+    #[wasm_bindgen(method)]
+    pub fn reduce(
+        this: &Array,
+        predicate: &mut dyn FnMut(JsValue, JsValue, u32, Array) -> JsValue,
+        initial_value: &JsValue,
+    ) -> JsValue;
+
+    /// The `reduceRight()` method applies a function against an accumulator and each value
+    /// of the array (from right-to-left) to reduce it to a single value.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/ReduceRight)
+    #[wasm_bindgen(method, js_name = reduceRight)]
+    pub fn reduce_right(
+        this: &Array,
+        predicate: &mut dyn FnMut(JsValue, JsValue, u32, Array) -> JsValue,
+        initial_value: &JsValue,
+    ) -> JsValue;
+
+    /// The `reverse()` method reverses an array in place. The first array
+    /// element becomes the last, and the last array element becomes the first.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse)
+    #[wasm_bindgen(method)]
+    pub fn reverse(this: &Array) -> Array;
+
+    /// The `shift()` method removes the first element from an array and returns
+    /// that removed element. This method changes the length of the array.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift)
+    #[wasm_bindgen(method)]
+    pub fn shift(this: &Array) -> JsValue;
+
+    /// The `slice()` method returns a shallow copy of a portion of an array into
+    /// a new array object selected from begin to end (end not included).
+    /// The original array will not be modified.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice)
+    #[wasm_bindgen(method)]
+    pub fn slice(this: &Array, start: u32, end: u32) -> Array;
+
+    /// The `some()` method tests whether at least one element in the array passes the test implemented
+    /// by the provided function.
+    /// Note: This method returns false for any condition put on an empty array.
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)
+    #[wasm_bindgen(method)]
+    pub fn some(this: &Array, predicate: &mut dyn FnMut(JsValue) -> bool) -> bool;
+
+    /// The `sort()` method sorts the elements of an array in place and returns
+    /// the array. The sort is not necessarily stable. The default sort
+    /// order is according to string Unicode code points.
+    ///
+    /// The time and space complexity of the sort cannot be guaranteed as it
+    /// is implementation dependent.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)
+    #[wasm_bindgen(method)]
+    pub fn sort(this: &Array) -> Array;
+
+    /// The `splice()` method changes the contents of an array by removing existing elements and/or
+    /// adding new elements.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice)
+    #[wasm_bindgen(method)]
+    pub fn splice(this: &Array, start: u32, delete_count: u32, item: &JsValue) -> Array;
+
+    /// The `toLocaleString()` method returns a string representing the elements of the array.
+    /// The elements are converted to Strings using their toLocaleString methods and these
+    /// Strings are separated by a locale-specific String (such as a comma “,”).
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toLocaleString)
+    #[wasm_bindgen(method, js_name = toLocaleString)]
+    pub fn to_locale_string(this: &Array, locales: &JsValue, options: &JsValue) -> JsString;
+
+    /// The `toString()` method returns a string representing the specified array
+    /// and its elements.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString)
+    #[wasm_bindgen(method, js_name = toString)]
+    pub fn to_string(this: &Array) -> JsString;
+
+    /// The `unshift()` method adds one or more elements to the beginning of an
+    /// array and returns the new length of the array.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift)
+    #[wasm_bindgen(method)]
+    pub fn unshift(this: &Array, value: &JsValue) -> u32;
+}
+
+/// Iterator returned by `Array::iter`
+#[derive(Debug, Clone)]
+pub struct ArrayIter<'a> {
+    range: std::ops::Range<u32>,
+    array: &'a Array,
+}
+
+impl<'a> std::iter::Iterator for ArrayIter<'a> {
+    type Item = JsValue;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let index = self.range.next()?;
+        Some(self.array.get(index))
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.range.size_hint()
+    }
+}
+
+impl<'a> std::iter::DoubleEndedIterator for ArrayIter<'a> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        let index = self.range.next_back()?;
+        Some(self.array.get(index))
+    }
+}
+
+impl<'a> std::iter::FusedIterator for ArrayIter<'a> {}
+
+impl<'a> std::iter::ExactSizeIterator for ArrayIter<'a> {}
+
+impl Array {
+    /// Returns an iterator over the values of the JS array.
+    pub fn iter(&self) -> ArrayIter<'_> {
+        ArrayIter {
+            range: 0..self.length(),
+            array: self,
+        }
+    }
+
+    /// Converts the JS array into a new Vec.
+    pub fn to_vec(&self) -> Vec<JsValue> {
+        let len = self.length();
+
+        let mut output = Vec::with_capacity(len as usize);
+
+        for i in 0..len {
+            output.push(self.get(i));
+        }
+
+        output
+    }
+}
+
+// TODO pre-initialize the Array with the correct length using TrustedLen
+impl<A> std::iter::FromIterator<A> for Array
+where
+    A: AsRef<JsValue>,
+{
+    fn from_iter<T>(iter: T) -> Array
+    where
+        T: IntoIterator<Item = A>,
+    {
+        let mut out = Array::new();
+        out.extend(iter);
+        out
+    }
+}
+
+impl<A> std::iter::Extend<A> for Array
+where
+    A: AsRef<JsValue>,
+{
+    fn extend<T>(&mut self, iter: T)
+    where
+        T: IntoIterator<Item = A>,
+    {
+        for value in iter {
+            self.push(value.as_ref());
+        }
+    }
+}
+
+impl Default for Array {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+// ArrayBuffer
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(extends = Object, typescript_type = "ArrayBuffer")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type ArrayBuffer;
+
+    /// The `ArrayBuffer` object is used to represent a generic,
+    /// fixed-length raw binary data buffer. You cannot directly
+    /// manipulate the contents of an `ArrayBuffer`; instead, you
+    /// create one of the typed array objects or a `DataView` object
+    /// which represents the buffer in a specific format, and use that
+    /// to read and write the contents of the buffer.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)
+    #[wasm_bindgen(constructor)]
+    pub fn new(length: u32) -> ArrayBuffer;
+
+    /// The byteLength property of an object which is an instance of type ArrayBuffer
+    /// it's an accessor property whose set accessor function is undefined,
+    /// meaning that you can only read this property.
+    /// The value is established when the array is constructed and cannot be changed.
+    /// This property returns 0 if this ArrayBuffer has been detached.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/byteLength)
+    #[wasm_bindgen(method, getter, js_name = byteLength)]
+    pub fn byte_length(this: &ArrayBuffer) -> u32;
+
+    /// The `isView()` method returns true if arg is one of the `ArrayBuffer`
+    /// views, such as typed array objects or a DataView; false otherwise.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/isView)
+    #[wasm_bindgen(static_method_of = ArrayBuffer, js_name = isView)]
+    pub fn is_view(value: &JsValue) -> bool;
+
+    /// The `slice()` method returns a new `ArrayBuffer` whose contents
+    /// are a copy of this `ArrayBuffer`'s bytes from begin, inclusive,
+    /// up to end, exclusive.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/slice)
+    #[wasm_bindgen(method)]
+    pub fn slice(this: &ArrayBuffer, begin: u32) -> ArrayBuffer;
+
+    /// Like `slice()` but with the `end` argument.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/slice)
+    #[wasm_bindgen(method, js_name = slice)]
+    pub fn slice_with_end(this: &ArrayBuffer, begin: u32, end: u32) -> ArrayBuffer;
+}
+
+// SharedArrayBuffer
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(extends = Object, typescript_type = "SharedArrayBuffer")]
+    #[derive(Clone, Debug)]
+    pub type SharedArrayBuffer;
+
+    /// The `SharedArrayBuffer` object is used to represent a generic,
+    /// fixed-length raw binary data buffer, similar to the `ArrayBuffer`
+    /// object, but in a way that they can be used to create views
+    /// on shared memory. Unlike an `ArrayBuffer`, a `SharedArrayBuffer`
+    /// cannot become detached.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer)
+    #[wasm_bindgen(constructor)]
+    pub fn new(length: u32) -> SharedArrayBuffer;
+
+    /// The byteLength accessor property represents the length of
+    /// an `SharedArrayBuffer` in bytes. This is established when
+    /// the `SharedArrayBuffer` is constructed and cannot be changed.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer/byteLength)
+    #[wasm_bindgen(method, getter, js_name = byteLength)]
+    pub fn byte_length(this: &SharedArrayBuffer) -> u32;
+
+    /// The `slice()` method returns a new `SharedArrayBuffer` whose contents
+    /// are a copy of this `SharedArrayBuffer`'s bytes from begin, inclusive,
+    /// up to end, exclusive.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer/slice)
+    #[wasm_bindgen(method)]
+    pub fn slice(this: &SharedArrayBuffer, begin: u32) -> SharedArrayBuffer;
+
+    /// Like `slice()` but with the `end` argument.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer/slice)
+    #[wasm_bindgen(method, js_name = slice)]
+    pub fn slice_with_end(this: &SharedArrayBuffer, begin: u32, end: u32) -> SharedArrayBuffer;
+}
+
+// Array Iterator
+#[wasm_bindgen]
+extern "C" {
+    /// The `keys()` method returns a new Array Iterator object that contains the
+    /// keys for each index in the array.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/keys)
+    #[wasm_bindgen(method)]
+    pub fn keys(this: &Array) -> Iterator;
+
+    /// The `entries()` method returns a new Array Iterator object that contains
+    /// the key/value pairs for each index in the array.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/entries)
+    #[wasm_bindgen(method)]
+    pub fn entries(this: &Array) -> Iterator;
+
+    /// The `values()` method returns a new Array Iterator object that
+    /// contains the values for each index in the array.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/values)
+    #[wasm_bindgen(method)]
+    pub fn values(this: &Array) -> Iterator;
+}
+
+/// The `Atomics` object provides atomic operations as static methods.
+/// They are used with `SharedArrayBuffer` objects.
+///
+/// The Atomic operations are installed on an `Atomics` module. Unlike
+/// the other global objects, `Atomics` is not a constructor. You cannot
+/// use it with a new operator or invoke the `Atomics` object as a
+/// function. All properties and methods of `Atomics` are static
+/// (as is the case with the Math object, for example).
+/// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics)
+#[allow(non_snake_case)]
+pub mod Atomics {
+    use super::*;
+
+    #[wasm_bindgen]
+    extern "C" {
+        /// The static `Atomics.add()` method adds a given value at a given
+        /// position in the array and returns the old value at that position.
+        /// This atomic operation guarantees that no other write happens
+        /// until the modified value is written back.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/add)
+        #[wasm_bindgen(js_namespace = Atomics, catch)]
+        pub fn add(typed_array: &JsValue, index: u32, value: i32) -> Result<i32, JsValue>;
+
+        /// The static `Atomics.and()` method computes a bitwise AND with a given
+        /// value at a given position in the array, and returns the old value
+        /// at that position.
+        /// This atomic operation guarantees that no other write happens
+        /// until the modified value is written back.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/and)
+        #[wasm_bindgen(js_namespace = Atomics, catch)]
+        pub fn and(typed_array: &JsValue, index: u32, value: i32) -> Result<i32, JsValue>;
+
+        /// The static `Atomics.compareExchange()` method exchanges a given
+        /// replacement value at a given position in the array, if a given expected
+        /// value equals the old value. It returns the old value at that position
+        /// whether it was equal to the expected value or not.
+        /// This atomic operation guarantees that no other write happens
+        /// until the modified value is written back.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/compareExchange)
+        #[wasm_bindgen(js_namespace = Atomics, catch, js_name = compareExchange)]
+        pub fn compare_exchange(
+            typed_array: &JsValue,
+            index: u32,
+            expected_value: i32,
+            replacement_value: i32,
+        ) -> Result<i32, JsValue>;
+
+        /// The static `Atomics.exchange()` method stores a given value at a given
+        /// position in the array and returns the old value at that position.
+        /// This atomic operation guarantees that no other write happens
+        /// until the modified value is written back.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/exchange)
+        #[wasm_bindgen(js_namespace = Atomics, catch)]
+        pub fn exchange(typed_array: &JsValue, index: u32, value: i32) -> Result<i32, JsValue>;
+
+        /// The static `Atomics.isLockFree()` method is used to determine
+        /// whether to use locks or atomic operations. It returns true,
+        /// if the given size is one of the `BYTES_PER_ELEMENT` property
+        /// of integer `TypedArray` types.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/isLockFree)
+        #[wasm_bindgen(js_namespace = Atomics, js_name = isLockFree)]
+        pub fn is_lock_free(size: u32) -> bool;
+
+        /// The static `Atomics.load()` method returns a value at a given
+        /// position in the array.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/load)
+        #[wasm_bindgen(js_namespace = Atomics, catch)]
+        pub fn load(typed_array: &JsValue, index: u32) -> Result<i32, JsValue>;
+
+        /// The static `Atomics.notify()` method notifies up some agents that
+        /// are sleeping in the wait queue.
+        /// Note: This operation works with a shared `Int32Array` only.
+        /// If `count` is not provided, notifies all the agents in the queue.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/notify)
+        #[wasm_bindgen(js_namespace = Atomics, catch)]
+        pub fn notify(typed_array: &Int32Array, index: u32) -> Result<u32, JsValue>;
+
+        /// Notifies up to `count` agents in the wait queue.
+        #[wasm_bindgen(js_namespace = Atomics, catch, js_name = notify)]
+        pub fn notify_with_count(
+            typed_array: &Int32Array,
+            index: u32,
+            count: u32,
+        ) -> Result<u32, JsValue>;
+
+        /// The static `Atomics.or()` method computes a bitwise OR with a given value
+        /// at a given position in the array, and returns the old value at that position.
+        /// This atomic operation guarantees that no other write happens
+        /// until the modified value is written back.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/or)
+        #[wasm_bindgen(js_namespace = Atomics, catch)]
+        pub fn or(typed_array: &JsValue, index: u32, value: i32) -> Result<i32, JsValue>;
+
+        /// The static `Atomics.store()` method stores a given value at the given
+        /// position in the array and returns that value.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/store)
+        #[wasm_bindgen(js_namespace = Atomics, catch)]
+        pub fn store(typed_array: &JsValue, index: u32, value: i32) -> Result<i32, JsValue>;
+
+        /// The static `Atomics.sub()` method substracts a given value at a
+        /// given position in the array and returns the old value at that position.
+        /// This atomic operation guarantees that no other write happens
+        /// until the modified value is written back.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/sub)
+        #[wasm_bindgen(js_namespace = Atomics, catch)]
+        pub fn sub(typed_array: &JsValue, index: u32, value: i32) -> Result<i32, JsValue>;
+
+        /// The static `Atomics.wait()` method verifies that a given
+        /// position in an `Int32Array` still contains a given value
+        /// and if so sleeps, awaiting a wakeup or a timeout.
+        /// It returns a string which is either "ok", "not-equal", or "timed-out".
+        /// Note: This operation only works with a shared `Int32Array`
+        /// and may not be allowed on the main thread.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/wait)
+        #[wasm_bindgen(js_namespace = Atomics, catch)]
+        pub fn wait(typed_array: &Int32Array, index: u32, value: i32) -> Result<JsString, JsValue>;
+
+        /// Like `wait()`, but with timeout
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/wait)
+        #[wasm_bindgen(js_namespace = Atomics, catch, js_name = wait)]
+        pub fn wait_with_timeout(
+            typed_array: &Int32Array,
+            index: u32,
+            value: i32,
+            timeout: f64,
+        ) -> Result<JsString, JsValue>;
+
+        /// The static `Atomics.xor()` method computes a bitwise XOR
+        /// with a given value at a given position in the array,
+        /// and returns the old value at that position.
+        /// This atomic operation guarantees that no other write happens
+        /// until the modified value is written back.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/xor)
+        #[wasm_bindgen(js_namespace = Atomics, catch)]
+        pub fn xor(typed_array: &JsValue, index: u32, value: i32) -> Result<i32, JsValue>;
+    }
+}
+
+// BigInt
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(extends = Object, is_type_of = |v| v.is_bigint(), typescript_type = "bigint")]
+    #[derive(Clone, PartialEq, Eq)]
+    pub type BigInt;
+
+    #[wasm_bindgen(catch, js_name = BigInt)]
+    fn new_bigint(value: &JsValue) -> Result<BigInt, Error>;
+
+    #[wasm_bindgen(js_name = BigInt)]
+    fn new_bigint_unchecked(value: &JsValue) -> BigInt;
+
+    /// Clamps a BigInt value to a signed integer value, and returns that value.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/asIntN)
+    #[wasm_bindgen(static_method_of = BigInt, js_name = asIntN)]
+    pub fn as_int_n(bits: f64, bigint: &BigInt) -> BigInt;
+
+    /// Clamps a BigInt value to an unsigned integer value, and returns that value.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/asUintN)
+    #[wasm_bindgen(static_method_of = BigInt, js_name = asUintN)]
+    pub fn as_uint_n(bits: f64, bigint: &BigInt) -> BigInt;
+
+    /// Returns a string with a language-sensitive representation of this BigInt value. Overrides the [`Object.prototype.toLocaleString()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/toLocaleString) method.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/toLocaleString)
+    #[wasm_bindgen(method, js_name = toLocaleString)]
+    pub fn to_locale_string(this: &BigInt, locales: &JsValue, options: &JsValue) -> JsString;
+
+    /// Returns a string representing this BigInt value in the specified radix (base). Overrides the [`Object.prototype.toString()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString) method.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/toString)
+    #[wasm_bindgen(catch, method, js_name = toString)]
+    pub fn to_string(this: &BigInt, radix: u8) -> Result<JsString, RangeError>;
+
+    #[wasm_bindgen(method, js_name = toString)]
+    fn to_string_unchecked(this: &BigInt, radix: u8) -> String;
+
+    /// Returns this BigInt value. Overrides the [`Object.prototype.valueOf()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/valueOf) method.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/valueOf)
+    #[wasm_bindgen(method, js_name = valueOf)]
+    pub fn value_of(this: &BigInt, radix: u8) -> BigInt;
+}
+
+impl BigInt {
+    /// Creates a new BigInt value.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/BigInt)
+    #[inline]
+    pub fn new(value: &JsValue) -> Result<BigInt, Error> {
+        new_bigint(value)
+    }
+
+    /// Applies the binary `/` JS operator on two `BigInt`s, catching and returning any `RangeError` thrown.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Division)
+    pub fn checked_div(&self, rhs: &Self) -> Result<Self, RangeError> {
+        let result = JsValue::as_ref(self).checked_div(JsValue::as_ref(rhs));
+
+        if result.is_instance_of::<RangeError>() {
+            Err(result.unchecked_into())
+        } else {
+            Ok(result.unchecked_into())
+        }
+    }
+
+    /// Applies the binary `**` JS operator on the two `BigInt`s.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Exponentiation)
+    #[inline]
+    pub fn pow(&self, rhs: &Self) -> Self {
+        JsValue::as_ref(self)
+            .pow(JsValue::as_ref(rhs))
+            .unchecked_into()
+    }
+}
+
+macro_rules! bigint_from {
+    ($($x:ident)*) => ($(
+        impl From<$x> for BigInt {
+            #[inline]
+            fn from(x: $x) -> BigInt {
+                new_bigint_unchecked(&JsValue::from(x))
+            }
+        }
+
+        impl PartialEq<$x> for BigInt {
+            #[inline]
+            fn eq(&self, other: &$x) -> bool {
+                JsValue::from(self) == JsValue::from(BigInt::from(*other))
+            }
+        }
+    )*)
+}
+bigint_from!(i8 u8 i16 u16 i32 u32 isize usize);
+
+macro_rules! bigint_from_big {
+    ($($x:ident)*) => ($(
+        impl From<$x> for BigInt {
+            #[inline]
+            fn from(x: $x) -> BigInt {
+                JsValue::from(x).unchecked_into()
+            }
+        }
+
+        impl PartialEq<$x> for BigInt {
+            #[inline]
+            fn eq(&self, other: &$x) -> bool {
+                self == &BigInt::from(*other)
+            }
+        }
+
+        impl TryFrom<BigInt> for $x {
+            type Error = BigInt;
+
+            #[inline]
+            fn try_from(x: BigInt) -> Result<Self, BigInt> {
+                Self::try_from(JsValue::from(x)).map_err(JsCast::unchecked_into)
+            }
+        }
+    )*)
+}
+bigint_from_big!(i64 u64 i128 u128);
+
+impl PartialEq<Number> for BigInt {
+    #[inline]
+    fn eq(&self, other: &Number) -> bool {
+        JsValue::as_ref(self).loose_eq(JsValue::as_ref(other))
+    }
+}
+
+impl Not for &BigInt {
+    type Output = BigInt;
+
+    #[inline]
+    fn not(self) -> Self::Output {
+        JsValue::as_ref(self).bit_not().unchecked_into()
+    }
+}
+
+forward_deref_unop!(impl Not, not for BigInt);
+forward_js_unop!(impl Neg, neg for BigInt);
+forward_js_binop!(impl BitAnd, bitand for BigInt);
+forward_js_binop!(impl BitOr, bitor for BigInt);
+forward_js_binop!(impl BitXor, bitxor for BigInt);
+forward_js_binop!(impl Shl, shl for BigInt);
+forward_js_binop!(impl Shr, shr for BigInt);
+forward_js_binop!(impl Add, add for BigInt);
+forward_js_binop!(impl Sub, sub for BigInt);
+forward_js_binop!(impl Div, div for BigInt);
+forward_js_binop!(impl Mul, mul for BigInt);
+forward_js_binop!(impl Rem, rem for BigInt);
+sum_product!(BigInt);
+
+partialord_ord!(BigInt);
+
+impl Default for BigInt {
+    fn default() -> Self {
+        BigInt::from(i32::default())
+    }
+}
+
+impl FromStr for BigInt {
+    type Err = Error;
+
+    #[inline]
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        BigInt::new(&s.into())
+    }
+}
+
+impl fmt::Debug for BigInt {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, f)
+    }
+}
+
+impl fmt::Display for BigInt {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad_integral(self >= &BigInt::from(0), "", &self.to_string_unchecked(10))
+    }
+}
+
+impl fmt::Binary for BigInt {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad_integral(self >= &BigInt::from(0), "0b", &self.to_string_unchecked(2))
+    }
+}
+
+impl fmt::Octal for BigInt {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad_integral(self >= &BigInt::from(0), "0o", &self.to_string_unchecked(8))
+    }
+}
+
+impl fmt::LowerHex for BigInt {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad_integral(
+            self >= &BigInt::from(0),
+            "0x",
+            &self.to_string_unchecked(16),
+        )
+    }
+}
+
+impl fmt::UpperHex for BigInt {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut s: String = self.to_string_unchecked(16);
+        s.make_ascii_uppercase();
+        f.pad_integral(self >= &BigInt::from(0), "0x", &s)
+    }
+}
+
+// Boolean
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(extends = Object, is_type_of = |v| v.as_bool().is_some(), typescript_type = "boolean")]
+    #[derive(Clone, PartialEq, Eq)]
+    pub type Boolean;
+
+    /// The `Boolean()` constructor creates an object wrapper for a boolean value.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)
+    #[wasm_bindgen(constructor)]
+    #[deprecated(note = "recommended to use `Boolean::from` instead")]
+    #[allow(deprecated)]
+    pub fn new(value: &JsValue) -> Boolean;
+
+    /// The `valueOf()` method returns the primitive value of a `Boolean` object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean/valueOf)
+    #[wasm_bindgen(method, js_name = valueOf)]
+    pub fn value_of(this: &Boolean) -> bool;
+}
+
+impl From<bool> for Boolean {
+    #[inline]
+    fn from(b: bool) -> Boolean {
+        Boolean::unchecked_from_js(JsValue::from(b))
+    }
+}
+
+impl From<Boolean> for bool {
+    #[inline]
+    fn from(b: Boolean) -> bool {
+        b.value_of()
+    }
+}
+
+impl PartialEq<bool> for Boolean {
+    #[inline]
+    fn eq(&self, other: &bool) -> bool {
+        self.value_of() == *other
+    }
+}
+
+impl fmt::Debug for Boolean {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(&self.value_of(), f)
+    }
+}
+
+impl fmt::Display for Boolean {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(&self.value_of(), f)
+    }
+}
+
+impl Default for Boolean {
+    fn default() -> Self {
+        Self::from(bool::default())
+    }
+}
+
+impl Not for &Boolean {
+    type Output = Boolean;
+
+    #[inline]
+    fn not(self) -> Self::Output {
+        (!JsValue::as_ref(self)).into()
+    }
+}
+
+forward_deref_unop!(impl Not, not for Boolean);
+
+partialord_ord!(Boolean);
+
+// DataView
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(extends = Object, typescript_type = "DataView")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type DataView;
+
+    /// The `DataView` view provides a low-level interface for reading and
+    /// writing multiple number types in an `ArrayBuffer` irrespective of the
+    /// platform's endianness.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView)
+    #[wasm_bindgen(constructor)]
+    pub fn new(buffer: &ArrayBuffer, byteOffset: usize, byteLength: usize) -> DataView;
+
+    /// The ArrayBuffer referenced by this view. Fixed at construction time and thus read only.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/buffer)
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn buffer(this: &DataView) -> ArrayBuffer;
+
+    /// The length (in bytes) of this view from the start of its ArrayBuffer.
+    /// Fixed at construction time and thus read only.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/byteLength)
+    #[wasm_bindgen(method, getter, structural, js_name = byteLength)]
+    pub fn byte_length(this: &DataView) -> usize;
+
+    /// The offset (in bytes) of this view from the start of its ArrayBuffer.
+    /// Fixed at construction time and thus read only.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/byteOffset)
+    #[wasm_bindgen(method, getter, structural, js_name = byteOffset)]
+    pub fn byte_offset(this: &DataView) -> usize;
+
+    /// The `getInt8()` method gets a signed 8-bit integer (byte) at the
+    /// specified byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getInt8)
+    #[wasm_bindgen(method, js_name = getInt8)]
+    pub fn get_int8(this: &DataView, byte_offset: usize) -> i8;
+
+    /// The `getUint8()` method gets a unsigned 8-bit integer (byte) at the specified
+    /// byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getUint8)
+    #[wasm_bindgen(method, js_name = getUint8)]
+    pub fn get_uint8(this: &DataView, byte_offset: usize) -> u8;
+
+    /// The `getInt16()` method gets a signed 16-bit integer (short) at the specified
+    /// byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getInt16)
+    #[wasm_bindgen(method, js_name = getInt16)]
+    pub fn get_int16(this: &DataView, byte_offset: usize) -> i16;
+
+    /// The `getInt16()` method gets a signed 16-bit integer (short) at the specified
+    /// byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getInt16)
+    #[wasm_bindgen(method, js_name = getInt16)]
+    pub fn get_int16_endian(this: &DataView, byte_offset: usize, little_endian: bool) -> i16;
+
+    /// The `getUint16()` method gets an unsigned 16-bit integer (unsigned short) at the specified
+    /// byte offset from the start of the view.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getUint16)
+    #[wasm_bindgen(method, js_name = getUint16)]
+    pub fn get_uint16(this: &DataView, byte_offset: usize) -> u16;
+
+    /// The `getUint16()` method gets an unsigned 16-bit integer (unsigned short) at the specified
+    /// byte offset from the start of the view.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getUint16)
+    #[wasm_bindgen(method, js_name = getUint16)]
+    pub fn get_uint16_endian(this: &DataView, byte_offset: usize, little_endian: bool) -> u16;
+
+    /// The `getInt32()` method gets a signed 32-bit integer (long) at the specified
+    /// byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getInt32)
+    #[wasm_bindgen(method, js_name = getInt32)]
+    pub fn get_int32(this: &DataView, byte_offset: usize) -> i32;
+
+    /// The `getInt32()` method gets a signed 32-bit integer (long) at the specified
+    /// byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getInt32)
+    #[wasm_bindgen(method, js_name = getInt32)]
+    pub fn get_int32_endian(this: &DataView, byte_offset: usize, little_endian: bool) -> i32;
+
+    /// The `getUint32()` method gets an unsigned 32-bit integer (unsigned long) at the specified
+    /// byte offset from the start of the view.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getUint32)
+    #[wasm_bindgen(method, js_name = getUint32)]
+    pub fn get_uint32(this: &DataView, byte_offset: usize) -> u32;
+
+    /// The `getUint32()` method gets an unsigned 32-bit integer (unsigned long) at the specified
+    /// byte offset from the start of the view.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getUint32)
+    #[wasm_bindgen(method, js_name = getUint32)]
+    pub fn get_uint32_endian(this: &DataView, byte_offset: usize, little_endian: bool) -> u32;
+
+    /// The `getFloat32()` method gets a signed 32-bit float (float) at the specified
+    /// byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getFloat32)
+    #[wasm_bindgen(method, js_name = getFloat32)]
+    pub fn get_float32(this: &DataView, byte_offset: usize) -> f32;
+
+    /// The `getFloat32()` method gets a signed 32-bit float (float) at the specified
+    /// byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getFloat32)
+    #[wasm_bindgen(method, js_name = getFloat32)]
+    pub fn get_float32_endian(this: &DataView, byte_offset: usize, little_endian: bool) -> f32;
+
+    /// The `getFloat64()` method gets a signed 64-bit float (double) at the specified
+    /// byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getFloat64)
+    #[wasm_bindgen(method, js_name = getFloat64)]
+    pub fn get_float64(this: &DataView, byte_offset: usize) -> f64;
+
+    /// The `getFloat64()` method gets a signed 64-bit float (double) at the specified
+    /// byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getFloat64)
+    #[wasm_bindgen(method, js_name = getFloat64)]
+    pub fn get_float64_endian(this: &DataView, byte_offset: usize, little_endian: bool) -> f64;
+
+    /// The `setInt8()` method stores a signed 8-bit integer (byte) value at the
+    /// specified byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setInt8)
+    #[wasm_bindgen(method, js_name = setInt8)]
+    pub fn set_int8(this: &DataView, byte_offset: usize, value: i8);
+
+    /// The `setUint8()` method stores an unsigned 8-bit integer (byte) value at the
+    /// specified byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setUint8)
+    #[wasm_bindgen(method, js_name = setUint8)]
+    pub fn set_uint8(this: &DataView, byte_offset: usize, value: u8);
+
+    /// The `setInt16()` method stores a signed 16-bit integer (short) value at the
+    /// specified byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setInt16)
+    #[wasm_bindgen(method, js_name = setInt16)]
+    pub fn set_int16(this: &DataView, byte_offset: usize, value: i16);
+
+    /// The `setInt16()` method stores a signed 16-bit integer (short) value at the
+    /// specified byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setInt16)
+    #[wasm_bindgen(method, js_name = setInt16)]
+    pub fn set_int16_endian(this: &DataView, byte_offset: usize, value: i16, little_endian: bool);
+
+    /// The `setUint16()` method stores an unsigned 16-bit integer (unsigned short) value at the
+    /// specified byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setUint16)
+    #[wasm_bindgen(method, js_name = setUint16)]
+    pub fn set_uint16(this: &DataView, byte_offset: usize, value: u16);
+
+    /// The `setUint16()` method stores an unsigned 16-bit integer (unsigned short) value at the
+    /// specified byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setUint16)
+    #[wasm_bindgen(method, js_name = setUint16)]
+    pub fn set_uint16_endian(this: &DataView, byte_offset: usize, value: u16, little_endian: bool);
+
+    /// The `setInt32()` method stores a signed 32-bit integer (long) value at the
+    /// specified byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setInt32)
+    #[wasm_bindgen(method, js_name = setInt32)]
+    pub fn set_int32(this: &DataView, byte_offset: usize, value: i32);
+
+    /// The `setInt32()` method stores a signed 32-bit integer (long) value at the
+    /// specified byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setInt32)
+    #[wasm_bindgen(method, js_name = setInt32)]
+    pub fn set_int32_endian(this: &DataView, byte_offset: usize, value: i32, little_endian: bool);
+
+    /// The `setUint32()` method stores an unsigned 32-bit integer (unsigned long) value at the
+    /// specified byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setUint32)
+    #[wasm_bindgen(method, js_name = setUint32)]
+    pub fn set_uint32(this: &DataView, byte_offset: usize, value: u32);
+
+    /// The `setUint32()` method stores an unsigned 32-bit integer (unsigned long) value at the
+    /// specified byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setUint32)
+    #[wasm_bindgen(method, js_name = setUint32)]
+    pub fn set_uint32_endian(this: &DataView, byte_offset: usize, value: u32, little_endian: bool);
+
+    /// The `setFloat32()` method stores a signed 32-bit float (float) value at the
+    /// specified byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setFloat32)
+    #[wasm_bindgen(method, js_name = setFloat32)]
+    pub fn set_float32(this: &DataView, byte_offset: usize, value: f32);
+
+    /// The `setFloat32()` method stores a signed 32-bit float (float) value at the
+    /// specified byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setFloat32)
+    #[wasm_bindgen(method, js_name = setFloat32)]
+    pub fn set_float32_endian(this: &DataView, byte_offset: usize, value: f32, little_endian: bool);
+
+    /// The `setFloat64()` method stores a signed 64-bit float (double) value at the
+    /// specified byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setFloat64)
+    #[wasm_bindgen(method, js_name = setFloat64)]
+    pub fn set_float64(this: &DataView, byte_offset: usize, value: f64);
+
+    /// The `setFloat64()` method stores a signed 64-bit float (double) value at the
+    /// specified byte offset from the start of the DataView.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setFloat64)
+    #[wasm_bindgen(method, js_name = setFloat64)]
+    pub fn set_float64_endian(this: &DataView, byte_offset: usize, value: f64, little_endian: bool);
+}
+
+// Error
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(extends = Object, typescript_type = "Error")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type Error;
+
+    /// The Error constructor creates an error object.
+    /// Instances of Error objects are thrown when runtime errors occur.
+    /// The Error object can also be used as a base object for user-defined exceptions.
+    /// See below for standard built-in error types.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)
+    #[wasm_bindgen(constructor)]
+    pub fn new(message: &str) -> Error;
+    #[wasm_bindgen(constructor)]
+    pub fn new_with_options(message: &str, options: &Object) -> Error;
+
+    /// The cause property is the underlying cause of the error.
+    /// Usually this is used to add context to re-thrown errors.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#differentiate_between_similar_errors)
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn cause(this: &Error) -> JsValue;
+    #[wasm_bindgen(method, setter, structural)]
+    pub fn set_cause(this: &Error, cause: &JsValue);
+
+    /// The message property is a human-readable description of the error.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/message)
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn message(this: &Error) -> JsString;
+    #[wasm_bindgen(method, setter, structural)]
+    pub fn set_message(this: &Error, message: &str);
+
+    /// The name property represents a name for the type of error. The initial value is "Error".
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/name)
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn name(this: &Error) -> JsString;
+    #[wasm_bindgen(method, setter, structural)]
+    pub fn set_name(this: &Error, name: &str);
+
+    /// The `toString()` method returns a string representing the specified Error object
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/toString)
+    #[wasm_bindgen(method, js_name = toString)]
+    pub fn to_string(this: &Error) -> JsString;
+}
+
+partialord_ord!(JsString);
+
+// EvalError
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(extends = Object, extends = Error, typescript_type = "EvalError")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type EvalError;
+
+    /// The EvalError object indicates an error regarding the global eval() function. This
+    /// exception is not thrown by JavaScript anymore, however the EvalError object remains for
+    /// compatibility.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError)
+    #[wasm_bindgen(constructor)]
+    pub fn new(message: &str) -> EvalError;
+}
+
+// Function
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(extends = Object, is_type_of = JsValue::is_function, typescript_type = "Function")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type Function;
+
+    /// The `Function` constructor creates a new `Function` object. Calling the
+    /// constructor directly can create functions dynamically, but suffers from
+    /// security and similar (but far less significant) performance issues
+    /// similar to `eval`. However, unlike `eval`, the `Function` constructor
+    /// allows executing code in the global scope, prompting better programming
+    /// habits and allowing for more efficient code minification.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function)
+    #[wasm_bindgen(constructor)]
+    pub fn new_with_args(args: &str, body: &str) -> Function;
+
+    /// The `Function` constructor creates a new `Function` object. Calling the
+    /// constructor directly can create functions dynamically, but suffers from
+    /// security and similar (but far less significant) performance issues
+    /// similar to `eval`. However, unlike `eval`, the `Function` constructor
+    /// allows executing code in the global scope, prompting better programming
+    /// habits and allowing for more efficient code minification.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function)
+    #[wasm_bindgen(constructor)]
+    pub fn new_no_args(body: &str) -> Function;
+
+    /// The `apply()` method calls a function with a given this value, and arguments provided as an array
+    /// (or an array-like object).
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply)
+    #[wasm_bindgen(method, catch)]
+    pub fn apply(this: &Function, context: &JsValue, args: &Array) -> Result<JsValue, JsValue>;
+
+    /// The `call()` method calls a function with a given this value and
+    /// arguments provided individually.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/call)
+    #[wasm_bindgen(method, catch, js_name = call)]
+    pub fn call0(this: &Function, context: &JsValue) -> Result<JsValue, JsValue>;
+
+    /// The `call()` method calls a function with a given this value and
+    /// arguments provided individually.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/call)
+    #[wasm_bindgen(method, catch, js_name = call)]
+    pub fn call1(this: &Function, context: &JsValue, arg1: &JsValue) -> Result<JsValue, JsValue>;
+
+    /// The `call()` method calls a function with a given this value and
+    /// arguments provided individually.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/call)
+    #[wasm_bindgen(method, catch, js_name = call)]
+    pub fn call2(
+        this: &Function,
+        context: &JsValue,
+        arg1: &JsValue,
+        arg2: &JsValue,
+    ) -> Result<JsValue, JsValue>;
+
+    /// The `call()` method calls a function with a given this value and
+    /// arguments provided individually.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/call)
+    #[wasm_bindgen(method, catch, js_name = call)]
+    pub fn call3(
+        this: &Function,
+        context: &JsValue,
+        arg1: &JsValue,
+        arg2: &JsValue,
+        arg3: &JsValue,
+    ) -> Result<JsValue, JsValue>;
+
+    /// The `bind()` method creates a new function that, when called, has its this keyword set to the provided value,
+    /// with a given sequence of arguments preceding any provided when the new function is called.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind)
+    #[wasm_bindgen(method, js_name = bind)]
+    pub fn bind(this: &Function, context: &JsValue) -> Function;
+
+    /// The `bind()` method creates a new function that, when called, has its this keyword set to the provided value,
+    /// with a given sequence of arguments preceding any provided when the new function is called.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind)
+    #[wasm_bindgen(method, js_name = bind)]
+    pub fn bind0(this: &Function, context: &JsValue) -> Function;
+
+    /// The `bind()` method creates a new function that, when called, has its this keyword set to the provided value,
+    /// with a given sequence of arguments preceding any provided when the new function is called.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind)
+    #[wasm_bindgen(method, js_name = bind)]
+    pub fn bind1(this: &Function, context: &JsValue, arg1: &JsValue) -> Function;
+
+    /// The `bind()` method creates a new function that, when called, has its this keyword set to the provided value,
+    /// with a given sequence of arguments preceding any provided when the new function is called.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind)
+    #[wasm_bindgen(method, js_name = bind)]
+    pub fn bind2(this: &Function, context: &JsValue, arg1: &JsValue, arg2: &JsValue) -> Function;
+
+    /// The `bind()` method creates a new function that, when called, has its this keyword set to the provided value,
+    /// with a given sequence of arguments preceding any provided when the new function is called.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind)
+    #[wasm_bindgen(method, js_name = bind)]
+    pub fn bind3(
+        this: &Function,
+        context: &JsValue,
+        arg1: &JsValue,
+        arg2: &JsValue,
+        arg3: &JsValue,
+    ) -> Function;
+
+    /// The length property indicates the number of arguments expected by the function.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/length)
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn length(this: &Function) -> u32;
+
+    /// A Function object's read-only name property indicates the function's
+    /// name as specified when it was created or "anonymous" for functions
+    /// created anonymously.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name)
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn name(this: &Function) -> JsString;
+
+    /// The `toString()` method returns a string representing the source code of the function.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/toString)
+    #[wasm_bindgen(method, js_name = toString)]
+    pub fn to_string(this: &Function) -> JsString;
+}
+
+impl Function {
+    /// Returns the `Function` value of this JS value if it's an instance of a
+    /// function.
+    ///
+    /// If this JS value is not an instance of a function then this returns
+    /// `None`.
+    #[deprecated(note = "recommended to use dyn_ref instead which is now equivalent")]
+    pub fn try_from(val: &JsValue) -> Option<&Function> {
+        val.dyn_ref()
+    }
+}
+
+impl Default for Function {
+    fn default() -> Self {
+        Self::new_no_args("")
+    }
+}
+
+// Generator
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(extends = Object, typescript_type = "Generator<any, any, any>")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type Generator;
+
+    /// The `next()` method returns an object with two properties done and value.
+    /// You can also provide a parameter to the next method to send a value to the generator.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Generator/next)
+    #[wasm_bindgen(method, structural, catch)]
+    pub fn next(this: &Generator, value: &JsValue) -> Result<JsValue, JsValue>;
+
+    /// The `return()` method returns the given value and finishes the generator.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Generator/return)
+    #[wasm_bindgen(method, structural, js_name = return)]
+    pub fn return_(this: &Generator, value: &JsValue) -> JsValue;
+
+    /// The `throw()` method resumes the execution of a generator by throwing an error into it
+    /// and returns an object with two properties done and value.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Generator/throw)
+    #[wasm_bindgen(method, structural, catch)]
+    pub fn throw(this: &Generator, error: &Error) -> Result<JsValue, JsValue>;
+}
+
+// Map
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(extends = Object, typescript_type = "Map<any, any>")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type Map;
+
+    /// The `clear()` method removes all elements from a Map object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/clear)
+    #[wasm_bindgen(method)]
+    pub fn clear(this: &Map);
+
+    /// The `delete()` method removes the specified element from a Map object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/delete)
+    #[wasm_bindgen(method)]
+    pub fn delete(this: &Map, key: &JsValue) -> bool;
+
+    /// The `forEach()` method executes a provided function once per each
+    /// key/value pair in the Map object, in insertion order.
+    /// Note that in Javascript land the `Key` and `Value` are reversed compared to normal expectations:
+    /// # Examples
+    /// ```
+    /// let js_map = Map::new();
+    /// js_map.for_each(&mut |value, key| {
+    ///     // Do something here...
+    /// })
+    /// ```
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/forEach)
+    #[wasm_bindgen(method, js_name = forEach)]
+    pub fn for_each(this: &Map, callback: &mut dyn FnMut(JsValue, JsValue));
+
+    /// The `get()` method returns a specified element from a Map object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get)
+    #[wasm_bindgen(method)]
+    pub fn get(this: &Map, key: &JsValue) -> JsValue;
+
+    /// The `has()` method returns a boolean indicating whether an element with
+    /// the specified key exists or not.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/has)
+    #[wasm_bindgen(method)]
+    pub fn has(this: &Map, key: &JsValue) -> bool;
+
+    /// The Map object holds key-value pairs. Any value (both objects and
+    /// primitive values) maybe used as either a key or a value.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map)
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Map;
+
+    /// The `set()` method adds or updates an element with a specified key
+    /// and value to a Map object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/set)
+    #[wasm_bindgen(method)]
+    pub fn set(this: &Map, key: &JsValue, value: &JsValue) -> Map;
+
+    /// The value of size is an integer representing how many entries
+    /// the Map object has. A set accessor function for size is undefined;
+    /// you can not change this property.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/size)
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn size(this: &Map) -> u32;
+}
+
+impl Default for Map {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+// Map Iterator
+#[wasm_bindgen]
+extern "C" {
+    /// The `entries()` method returns a new Iterator object that contains
+    /// the [key, value] pairs for each element in the Map object in
+    /// insertion order.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries)
+    #[wasm_bindgen(method)]
+    pub fn entries(this: &Map) -> Iterator;
+
+    /// The `keys()` method returns a new Iterator object that contains the
+    /// keys for each element in the Map object in insertion order.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/keys)
+    #[wasm_bindgen(method)]
+    pub fn keys(this: &Map) -> Iterator;
+
+    /// The `values()` method returns a new Iterator object that contains the
+    /// values for each element in the Map object in insertion order.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/values)
+    #[wasm_bindgen(method)]
+    pub fn values(this: &Map) -> Iterator;
+}
+
+// Iterator
+#[wasm_bindgen]
+extern "C" {
+    /// Any object that conforms to the JS iterator protocol. For example,
+    /// something returned by `myArray[Symbol.iterator]()`.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols)
+    #[derive(Clone, Debug)]
+    #[wasm_bindgen(is_type_of = Iterator::looks_like_iterator, typescript_type = "Iterator<any>")]
+    pub type Iterator;
+
+    /// The `next()` method always has to return an object with appropriate
+    /// properties including done and value. If a non-object value gets returned
+    /// (such as false or undefined), a TypeError ("iterator.next() returned a
+    /// non-object value") will be thrown.
+    #[wasm_bindgen(catch, method, structural)]
+    pub fn next(this: &Iterator) -> Result<IteratorNext, JsValue>;
+}
+
+impl Iterator {
+    fn looks_like_iterator(it: &JsValue) -> bool {
+        #[wasm_bindgen]
+        extern "C" {
+            type MaybeIterator;
+
+            #[wasm_bindgen(method, getter)]
+            fn next(this: &MaybeIterator) -> JsValue;
+        }
+
+        if !it.is_object() {
+            return false;
+        }
+
+        let it = it.unchecked_ref::<MaybeIterator>();
+
+        it.next().is_function()
+    }
+}
+
+// Async Iterator
+#[wasm_bindgen]
+extern "C" {
+    /// Any object that conforms to the JS async iterator protocol. For example,
+    /// something returned by `myObject[Symbol.asyncIterator]()`.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of)
+    #[derive(Clone, Debug)]
+    #[wasm_bindgen(is_type_of = Iterator::looks_like_iterator, typescript_type = "AsyncIterator<any>")]
+    pub type AsyncIterator;
+
+    /// The `next()` method always has to return a Promise which resolves to an object
+    /// with appropriate properties including done and value. If a non-object value
+    /// gets returned (such as false or undefined), a TypeError ("iterator.next()
+    /// returned a non-object value") will be thrown.
+    #[wasm_bindgen(catch, method, structural)]
+    pub fn next(this: &AsyncIterator) -> Result<Promise, JsValue>;
+}
+
+/// An iterator over the JS `Symbol.iterator` iteration protocol.
+///
+/// Use the `IntoIterator for &js_sys::Iterator` implementation to create this.
+pub struct Iter<'a> {
+    js: &'a Iterator,
+    state: IterState,
+}
+
+/// An iterator over the JS `Symbol.iterator` iteration protocol.
+///
+/// Use the `IntoIterator for js_sys::Iterator` implementation to create this.
+pub struct IntoIter {
+    js: Iterator,
+    state: IterState,
+}
+
+struct IterState {
+    done: bool,
+}
+
+impl<'a> IntoIterator for &'a Iterator {
+    type Item = Result<JsValue, JsValue>;
+    type IntoIter = Iter<'a>;
+
+    fn into_iter(self) -> Iter<'a> {
+        Iter {
+            js: self,
+            state: IterState::new(),
+        }
+    }
+}
+
+impl<'a> std::iter::Iterator for Iter<'a> {
+    type Item = Result<JsValue, JsValue>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.state.next(self.js)
+    }
+}
+
+impl IntoIterator for Iterator {
+    type Item = Result<JsValue, JsValue>;
+    type IntoIter = IntoIter;
+
+    fn into_iter(self) -> IntoIter {
+        IntoIter {
+            js: self,
+            state: IterState::new(),
+        }
+    }
+}
+
+impl std::iter::Iterator for IntoIter {
+    type Item = Result<JsValue, JsValue>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.state.next(&self.js)
+    }
+}
+
+impl IterState {
+    fn new() -> IterState {
+        IterState { done: false }
+    }
+
+    fn next(&mut self, js: &Iterator) -> Option<Result<JsValue, JsValue>> {
+        if self.done {
+            return None;
+        }
+        let next = match js.next() {
+            Ok(val) => val,
+            Err(e) => {
+                self.done = true;
+                return Some(Err(e));
+            }
+        };
+        if next.done() {
+            self.done = true;
+            None
+        } else {
+            Some(Ok(next.value()))
+        }
+    }
+}
+
+/// Create an iterator over `val` using the JS iteration protocol and
+/// `Symbol.iterator`.
+pub fn try_iter(val: &JsValue) -> Result<Option<IntoIter>, JsValue> {
+    let iter_sym = Symbol::iterator();
+    let iter_fn = Reflect::get(val, iter_sym.as_ref())?;
+
+    let iter_fn: Function = match iter_fn.dyn_into() {
+        Ok(iter_fn) => iter_fn,
+        Err(_) => return Ok(None),
+    };
+
+    let it: Iterator = match iter_fn.call0(val)?.dyn_into() {
+        Ok(it) => it,
+        Err(_) => return Ok(None),
+    };
+
+    Ok(Some(it.into_iter()))
+}
+
+// IteratorNext
+#[wasm_bindgen]
+extern "C" {
+    /// The result of calling `next()` on a JS iterator.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols)
+    #[wasm_bindgen(extends = Object, typescript_type = "IteratorResult<any>")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type IteratorNext;
+
+    /// Has the value `true` if the iterator is past the end of the iterated
+    /// sequence. In this case value optionally specifies the return value of
+    /// the iterator.
+    ///
+    /// Has the value `false` if the iterator was able to produce the next value
+    /// in the sequence. This is equivalent of not specifying the done property
+    /// altogether.
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn done(this: &IteratorNext) -> bool;
+
+    /// Any JavaScript value returned by the iterator. Can be omitted when done
+    /// is true.
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn value(this: &IteratorNext) -> JsValue;
+}
+
+#[allow(non_snake_case)]
+pub mod Math {
+    use super::*;
+
+    // Math
+    #[wasm_bindgen]
+    extern "C" {
+        /// The `Math.abs()` function returns the absolute value of a number, that is
+        /// Math.abs(x) = |x|
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/abs)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn abs(x: f64) -> f64;
+
+        /// The `Math.acos()` function returns the arccosine (in radians) of a
+        /// number, that is ∀x∊[-1;1]
+        /// Math.acos(x) = arccos(x) = the unique y∊[0;π] such that cos(y)=x
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/acos)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn acos(x: f64) -> f64;
+
+        /// The `Math.acosh()` function returns the hyperbolic arc-cosine of a
+        /// number, that is ∀x ≥ 1
+        /// Math.acosh(x) = arcosh(x) = the unique y ≥ 0 such that cosh(y) = x
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/acosh)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn acosh(x: f64) -> f64;
+
+        /// The `Math.asin()` function returns the arcsine (in radians) of a
+        /// number, that is ∀x ∊ [-1;1]
+        /// Math.asin(x) = arcsin(x) = the unique y∊[-π2;π2] such that sin(y) = x
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/asin)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn asin(x: f64) -> f64;
+
+        /// The `Math.asinh()` function returns the hyperbolic arcsine of a
+        /// number, that is Math.asinh(x) = arsinh(x) = the unique y such that sinh(y) = x
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/asinh)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn asinh(x: f64) -> f64;
+
+        /// The `Math.atan()` function returns the arctangent (in radians) of a
+        /// number, that is Math.atan(x) = arctan(x) = the unique y ∊ [-π2;π2]such that
+        /// tan(y) = x
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn atan(x: f64) -> f64;
+
+        /// The `Math.atan2()` function returns the arctangent of the quotient of
+        /// its arguments.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atan2)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn atan2(y: f64, x: f64) -> f64;
+
+        /// The `Math.atanh()` function returns the hyperbolic arctangent of a number,
+        /// that is ∀x ∊ (-1,1), Math.atanh(x) = arctanh(x) = the unique y such that
+        /// tanh(y) = x
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atanh)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn atanh(x: f64) -> f64;
+
+        /// The `Math.cbrt() `function returns the cube root of a number, that is
+        /// Math.cbrt(x) = ∛x = the unique y such that y^3 = x
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cbrt)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn cbrt(x: f64) -> f64;
+
+        /// The `Math.ceil()` function returns the smallest integer greater than
+        /// or equal to a given number.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn ceil(x: f64) -> f64;
+
+        /// The `Math.clz32()` function returns the number of leading zero bits in
+        /// the 32-bit binary representation of a number.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn clz32(x: i32) -> u32;
+
+        /// The `Math.cos()` static function returns the cosine of the specified angle,
+        /// which must be specified in radians. This value is length(adjacent)/length(hypotenuse).
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cos)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn cos(x: f64) -> f64;
+
+        /// The `Math.cosh()` function returns the hyperbolic cosine of a number,
+        /// that can be expressed using the constant e.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cosh)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn cosh(x: f64) -> f64;
+
+        /// The `Math.exp()` function returns e^x, where x is the argument, and e is Euler's number
+        /// (also known as Napier's constant), the base of the natural logarithms.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/exp)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn exp(x: f64) -> f64;
+
+        /// The `Math.expm1()` function returns e^x - 1, where x is the argument, and e the base of the
+        /// natural logarithms.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/expm1)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn expm1(x: f64) -> f64;
+
+        /// The `Math.floor()` function returns the largest integer less than or
+        /// equal to a given number.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn floor(x: f64) -> f64;
+
+        /// The `Math.fround()` function returns the nearest 32-bit single precision float representation
+        /// of a Number.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn fround(x: f64) -> f32;
+
+        /// The `Math.hypot()` function returns the square root of the sum of squares of its arguments.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/hypot)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn hypot(x: f64, y: f64) -> f64;
+
+        /// The `Math.imul()` function returns the result of the C-like 32-bit multiplication of the
+        /// two parameters.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn imul(x: i32, y: i32) -> i32;
+
+        /// The `Math.log()` function returns the natural logarithm (base e) of a number.
+        /// The JavaScript `Math.log()` function is equivalent to ln(x) in mathematics.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn log(x: f64) -> f64;
+
+        /// The `Math.log10()` function returns the base 10 logarithm of a number.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log10)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn log10(x: f64) -> f64;
+
+        /// The `Math.log1p()` function returns the natural logarithm (base e) of 1 + a number.
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log1p)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn log1p(x: f64) -> f64;
+
+        /// The `Math.log2()` function returns the base 2 logarithm of a number.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log2)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn log2(x: f64) -> f64;
+
+        /// The `Math.max()` function returns the largest of two numbers.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn max(x: f64, y: f64) -> f64;
+
+        /// The static function `Math.min()` returns the lowest-valued number passed into it.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn min(x: f64, y: f64) -> f64;
+
+        /// The `Math.pow()` function returns the base to the exponent power, that is, base^exponent.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/pow)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn pow(base: f64, exponent: f64) -> f64;
+
+        /// The `Math.random()` function returns a floating-point, pseudo-random number
+        /// in the range 0–1 (inclusive of 0, but not 1) with approximately uniform distribution
+        /// over that range — which you can then scale to your desired range.
+        /// The implementation selects the initial seed to the random number generation algorithm;
+        /// it cannot be chosen or reset by the user.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn random() -> f64;
+
+        /// The `Math.round()` function returns the value of a number rounded to the nearest integer.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn round(x: f64) -> f64;
+
+        /// The `Math.sign()` function returns the sign of a number, indicating whether the number is
+        /// positive, negative or zero.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn sign(x: f64) -> f64;
+
+        /// The `Math.sin()` function returns the sine of a number.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sin)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn sin(x: f64) -> f64;
+
+        /// The `Math.sinh()` function returns the hyperbolic sine of a number, that can be expressed
+        /// using the constant e: Math.sinh(x) = (e^x - e^-x)/2
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sinh)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn sinh(x: f64) -> f64;
+
+        /// The `Math.sqrt()` function returns the square root of a number, that is
+        /// ∀x ≥ 0, Math.sqrt(x) = √x = the unique y ≥ 0 such that y^2 = x
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sqrt)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn sqrt(x: f64) -> f64;
+
+        /// The `Math.tan()` function returns the tangent of a number.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/tan)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn tan(x: f64) -> f64;
+
+        /// The `Math.tanh()` function returns the hyperbolic tangent of a number, that is
+        /// tanh x = sinh x / cosh x = (e^x - e^-x)/(e^x + e^-x) = (e^2x - 1)/(e^2x + 1)
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/tanh)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn tanh(x: f64) -> f64;
+
+        /// The `Math.trunc()` function returns the integer part of a number by removing any fractional
+        /// digits.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc)
+        #[wasm_bindgen(js_namespace = Math)]
+        pub fn trunc(x: f64) -> f64;
+    }
+}
+
+// Number.
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(extends = Object, is_type_of = |v| v.as_f64().is_some(), typescript_type = "number")]
+    #[derive(Clone, PartialEq)]
+    pub type Number;
+
+    /// The `Number.isFinite()` method determines whether the passed value is a finite number.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite)
+    #[wasm_bindgen(static_method_of = Number, js_name = isFinite)]
+    pub fn is_finite(value: &JsValue) -> bool;
+
+    /// The `Number.isInteger()` method determines whether the passed value is an integer.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger)
+    #[wasm_bindgen(static_method_of = Number, js_name = isInteger)]
+    pub fn is_integer(value: &JsValue) -> bool;
+
+    /// The `Number.isNaN()` method determines whether the passed value is `NaN` and its type is Number.
+    /// It is a more robust version of the original, global isNaN().
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN)
+    #[wasm_bindgen(static_method_of = Number, js_name = isNaN)]
+    pub fn is_nan(value: &JsValue) -> bool;
+
+    /// The `Number.isSafeInteger()` method determines whether the provided value is a number
+    /// that is a safe integer.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger)
+    #[wasm_bindgen(static_method_of = Number, js_name = isSafeInteger)]
+    pub fn is_safe_integer(value: &JsValue) -> bool;
+
+    /// The `Number` JavaScript object is a wrapper object allowing
+    /// you to work with numerical values. A `Number` object is
+    /// created using the `Number()` constructor.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)
+    #[wasm_bindgen(constructor)]
+    #[deprecated(note = "recommended to use `Number::from` instead")]
+    #[allow(deprecated)]
+    pub fn new(value: &JsValue) -> Number;
+
+    #[wasm_bindgen(constructor)]
+    fn new_from_str(value: &str) -> Number;
+
+    /// The `Number.parseInt()` method parses a string argument and returns an
+    /// integer of the specified radix or base.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/parseInt)
+    #[wasm_bindgen(static_method_of = Number, js_name = parseInt)]
+    pub fn parse_int(text: &str, radix: u8) -> f64;
+
+    /// The `Number.parseFloat()` method parses a string argument and returns a
+    /// floating point number.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/parseFloat)
+    #[wasm_bindgen(static_method_of = Number, js_name = parseFloat)]
+    pub fn parse_float(text: &str) -> f64;
+
+    /// The `toLocaleString()` method returns a string with a language sensitive
+    /// representation of this number.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString)
+    #[wasm_bindgen(method, js_name = toLocaleString)]
+    pub fn to_locale_string(this: &Number, locale: &str) -> JsString;
+
+    /// The `toPrecision()` method returns a string representing the Number
+    /// object to the specified precision.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toPrecision)
+    #[wasm_bindgen(catch, method, js_name = toPrecision)]
+    pub fn to_precision(this: &Number, precision: u8) -> Result<JsString, JsValue>;
+
+    /// The `toFixed()` method returns a string representing the Number
+    /// object using fixed-point notation.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed)
+    #[wasm_bindgen(catch, method, js_name = toFixed)]
+    pub fn to_fixed(this: &Number, digits: u8) -> Result<JsString, JsValue>;
+
+    /// The `toExponential()` method returns a string representing the Number
+    /// object in exponential notation.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toExponential)
+    #[wasm_bindgen(catch, method, js_name = toExponential)]
+    pub fn to_exponential(this: &Number, fraction_digits: u8) -> Result<JsString, JsValue>;
+
+    /// The `toString()` method returns a string representing the
+    /// specified Number object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toString)
+    #[wasm_bindgen(catch, method, js_name = toString)]
+    pub fn to_string(this: &Number, radix: u8) -> Result<JsString, JsValue>;
+
+    /// The `valueOf()` method returns the wrapped primitive value of
+    /// a Number object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/valueOf)
+    #[wasm_bindgen(method, js_name = valueOf)]
+    pub fn value_of(this: &Number) -> f64;
+}
+
+impl Number {
+    /// The smallest interval between two representable numbers.
+    ///
+    /// [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/EPSILON)
+    pub const EPSILON: f64 = f64::EPSILON;
+    /// The maximum safe integer in JavaScript (2^53 - 1).
+    ///
+    /// [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER)
+    pub const MAX_SAFE_INTEGER: f64 = 9007199254740991.0;
+    /// The largest positive representable number.
+    ///
+    /// [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE)
+    pub const MAX_VALUE: f64 = f64::MAX;
+    /// The minimum safe integer in JavaScript (-(2^53 - 1)).
+    ///
+    /// [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MIN_SAFE_INTEGER)
+    pub const MIN_SAFE_INTEGER: f64 = -9007199254740991.0;
+    /// The smallest positive representable number—that is, the positive number closest to zero
+    /// (without actually being zero).
+    ///
+    /// [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE)
+    // Cannot use f64::MIN_POSITIVE since that is the smallest **normal** postitive number.
+    pub const MIN_VALUE: f64 = 5E-324;
+    /// Special "Not a Number" value.
+    ///
+    /// [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/NaN)
+    pub const NAN: f64 = f64::NAN;
+    /// Special value representing negative infinity. Returned on overflow.
+    ///
+    /// [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY)
+    pub const NEGATIVE_INFINITY: f64 = f64::NEG_INFINITY;
+    /// Special value representing infinity. Returned on overflow.
+    ///
+    /// [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY)
+    pub const POSITIVE_INFINITY: f64 = f64::INFINITY;
+
+    /// Applies the binary `**` JS operator on the two `Number`s.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Exponentiation)
+    #[inline]
+    pub fn pow(&self, rhs: &Self) -> Self {
+        JsValue::as_ref(self)
+            .pow(JsValue::as_ref(rhs))
+            .unchecked_into()
+    }
+
+    /// Applies the binary `>>>` JS operator on the two `Number`s.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Unsigned_right_shift)
+    #[inline]
+    pub fn unsigned_shr(&self, rhs: &Self) -> Self {
+        Number::from(JsValue::as_ref(self).unsigned_shr(JsValue::as_ref(rhs)))
+    }
+}
+
+macro_rules! number_from {
+    ($($x:ident)*) => ($(
+        impl From<$x> for Number {
+            #[inline]
+            fn from(x: $x) -> Number {
+                Number::unchecked_from_js(JsValue::from(x))
+            }
+        }
+
+        impl PartialEq<$x> for Number {
+            #[inline]
+            fn eq(&self, other: &$x) -> bool {
+                self.value_of() == f64::from(*other)
+            }
+        }
+    )*)
+}
+number_from!(i8 u8 i16 u16 i32 u32 f32 f64);
+
+// TODO: add this on the next major version, when blanket impl is removed
+/*
+impl convert::TryFrom<JsValue> for Number {
+    type Error = Error;
+
+    fn try_from(value: JsValue) -> Result<Self, Self::Error> {
+        return match f64::try_from(value) {
+            Ok(num) => Ok(Number::from(num)),
+            Err(jsval) => Err(jsval.unchecked_into())
+        }
+    }
+}
+*/
+
+impl From<&Number> for f64 {
+    #[inline]
+    fn from(n: &Number) -> f64 {
+        n.value_of()
+    }
+}
+
+impl From<Number> for f64 {
+    #[inline]
+    fn from(n: Number) -> f64 {
+        <f64 as From<&'_ Number>>::from(&n)
+    }
+}
+
+impl fmt::Debug for Number {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(&self.value_of(), f)
+    }
+}
+
+impl fmt::Display for Number {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(&self.value_of(), f)
+    }
+}
+
+impl Default for Number {
+    fn default() -> Self {
+        Self::from(f64::default())
+    }
+}
+
+impl PartialEq<BigInt> for Number {
+    #[inline]
+    fn eq(&self, other: &BigInt) -> bool {
+        JsValue::as_ref(self).loose_eq(JsValue::as_ref(other))
+    }
+}
+
+impl Not for &Number {
+    type Output = BigInt;
+
+    #[inline]
+    fn not(self) -> Self::Output {
+        JsValue::as_ref(self).bit_not().unchecked_into()
+    }
+}
+
+forward_deref_unop!(impl Not, not for Number);
+forward_js_unop!(impl Neg, neg for Number);
+forward_js_binop!(impl BitAnd, bitand for Number);
+forward_js_binop!(impl BitOr, bitor for Number);
+forward_js_binop!(impl BitXor, bitxor for Number);
+forward_js_binop!(impl Shl, shl for Number);
+forward_js_binop!(impl Shr, shr for Number);
+forward_js_binop!(impl Add, add for Number);
+forward_js_binop!(impl Sub, sub for Number);
+forward_js_binop!(impl Div, div for Number);
+forward_js_binop!(impl Mul, mul for Number);
+forward_js_binop!(impl Rem, rem for Number);
+
+sum_product!(Number);
+
+impl PartialOrd for Number {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        if Number::is_nan(self) || Number::is_nan(other) {
+            None
+        } else if self == other {
+            Some(Ordering::Equal)
+        } else if self.lt(other) {
+            Some(Ordering::Less)
+        } else {
+            Some(Ordering::Greater)
+        }
+    }
+
+    #[inline]
+    fn lt(&self, other: &Self) -> bool {
+        JsValue::as_ref(self).lt(JsValue::as_ref(other))
+    }
+
+    #[inline]
+    fn le(&self, other: &Self) -> bool {
+        JsValue::as_ref(self).le(JsValue::as_ref(other))
+    }
+
+    #[inline]
+    fn ge(&self, other: &Self) -> bool {
+        JsValue::as_ref(self).ge(JsValue::as_ref(other))
+    }
+
+    #[inline]
+    fn gt(&self, other: &Self) -> bool {
+        JsValue::as_ref(self).gt(JsValue::as_ref(other))
+    }
+}
+
+impl FromStr for Number {
+    type Err = Infallible;
+
+    #[allow(deprecated)]
+    #[inline]
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Number::new_from_str(s))
+    }
+}
+
+// Date.
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(extends = Object, typescript_type = "Date")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type Date;
+
+    /// The `getDate()` method returns the day of the month for the
+    /// specified date according to local time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getDate)
+    #[wasm_bindgen(method, js_name = getDate)]
+    pub fn get_date(this: &Date) -> u32;
+
+    /// The `getDay()` method returns the day of the week for the specified date according to local time,
+    /// where 0 represents Sunday. For the day of the month see getDate().
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getDay)
+    #[wasm_bindgen(method, js_name = getDay)]
+    pub fn get_day(this: &Date) -> u32;
+
+    /// The `getFullYear()` method returns the year of the specified date according to local time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getFullYear)
+    #[wasm_bindgen(method, js_name = getFullYear)]
+    pub fn get_full_year(this: &Date) -> u32;
+
+    /// The `getHours()` method returns the hour for the specified date, according to local time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getHours)
+    #[wasm_bindgen(method, js_name = getHours)]
+    pub fn get_hours(this: &Date) -> u32;
+
+    /// The `getMilliseconds()` method returns the milliseconds in the specified date according to local time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds)
+    #[wasm_bindgen(method, js_name = getMilliseconds)]
+    pub fn get_milliseconds(this: &Date) -> u32;
+
+    /// The `getMinutes()` method returns the minutes in the specified date according to local time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getMinutes)
+    #[wasm_bindgen(method, js_name = getMinutes)]
+    pub fn get_minutes(this: &Date) -> u32;
+
+    /// The `getMonth()` method returns the month in the specified date according to local time,
+    /// as a zero-based value (where zero indicates the first month of the year).
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getMonth)
+    #[wasm_bindgen(method, js_name = getMonth)]
+    pub fn get_month(this: &Date) -> u32;
+
+    /// The `getSeconds()` method returns the seconds in the specified date according to local time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getSeconds)
+    #[wasm_bindgen(method, js_name = getSeconds)]
+    pub fn get_seconds(this: &Date) -> u32;
+
+    /// The `getTime()` method returns the numeric value corresponding to the time for the specified date
+    /// according to universal time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTime)
+    #[wasm_bindgen(method, js_name = getTime)]
+    pub fn get_time(this: &Date) -> f64;
+
+    /// The `getTimezoneOffset()` method returns the time zone difference, in minutes,
+    /// from current locale (host system settings) to UTC.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset)
+    #[wasm_bindgen(method, js_name = getTimezoneOffset)]
+    pub fn get_timezone_offset(this: &Date) -> f64;
+
+    /// The `getUTCDate()` method returns the day (date) of the month in the specified date
+    /// according to universal time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCDate)
+    #[wasm_bindgen(method, js_name = getUTCDate)]
+    pub fn get_utc_date(this: &Date) -> u32;
+
+    /// The `getUTCDay()` method returns the day of the week in the specified date according to universal time,
+    /// where 0 represents Sunday.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCDay)
+    #[wasm_bindgen(method, js_name = getUTCDay)]
+    pub fn get_utc_day(this: &Date) -> u32;
+
+    /// The `getUTCFullYear()` method returns the year in the specified date according to universal time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCFullYear)
+    #[wasm_bindgen(method, js_name = getUTCFullYear)]
+    pub fn get_utc_full_year(this: &Date) -> u32;
+
+    /// The `getUTCHours()` method returns the hours in the specified date according to universal time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCHours)
+    #[wasm_bindgen(method, js_name = getUTCHours)]
+    pub fn get_utc_hours(this: &Date) -> u32;
+
+    /// The `getUTCMilliseconds()` method returns the milliseconds in the specified date
+    /// according to universal time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCMilliseconds)
+    #[wasm_bindgen(method, js_name = getUTCMilliseconds)]
+    pub fn get_utc_milliseconds(this: &Date) -> u32;
+
+    /// The `getUTCMinutes()` method returns the minutes in the specified date according to universal time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCMinutes)
+    #[wasm_bindgen(method, js_name = getUTCMinutes)]
+    pub fn get_utc_minutes(this: &Date) -> u32;
+
+    /// The `getUTCMonth()` returns the month of the specified date according to universal time,
+    /// as a zero-based value (where zero indicates the first month of the year).
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCMonth)
+    #[wasm_bindgen(method, js_name = getUTCMonth)]
+    pub fn get_utc_month(this: &Date) -> u32;
+
+    /// The `getUTCSeconds()` method returns the seconds in the specified date according to universal time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCSeconds)
+    #[wasm_bindgen(method, js_name = getUTCSeconds)]
+    pub fn get_utc_seconds(this: &Date) -> u32;
+
+    /// Creates a JavaScript `Date` instance that represents
+    /// a single moment in time. `Date` objects are based on a time value that is
+    /// the number of milliseconds since 1 January 1970 UTC.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date)
+    #[wasm_bindgen(constructor)]
+    pub fn new(init: &JsValue) -> Date;
+
+    /// Creates a JavaScript `Date` instance that represents the current moment in
+    /// time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date)
+    #[wasm_bindgen(constructor)]
+    pub fn new_0() -> Date;
+
+    /// Creates a JavaScript `Date` instance that represents
+    /// a single moment in time. `Date` objects are based on a time value that is
+    /// the number of milliseconds since 1 January 1970 UTC.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date)
+    #[wasm_bindgen(constructor)]
+    pub fn new_with_year_month(year: u32, month: i32) -> Date;
+
+    /// Creates a JavaScript `Date` instance that represents
+    /// a single moment in time. `Date` objects are based on a time value that is
+    /// the number of milliseconds since 1 January 1970 UTC.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date)
+    #[wasm_bindgen(constructor)]
+    pub fn new_with_year_month_day(year: u32, month: i32, day: i32) -> Date;
+
+    /// Creates a JavaScript `Date` instance that represents
+    /// a single moment in time. `Date` objects are based on a time value that is
+    /// the number of milliseconds since 1 January 1970 UTC.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date)
+    #[wasm_bindgen(constructor)]
+    pub fn new_with_year_month_day_hr(year: u32, month: i32, day: i32, hr: i32) -> Date;
+
+    /// Creates a JavaScript `Date` instance that represents
+    /// a single moment in time. `Date` objects are based on a time value that is
+    /// the number of milliseconds since 1 January 1970 UTC.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date)
+    #[wasm_bindgen(constructor)]
+    pub fn new_with_year_month_day_hr_min(
+        year: u32,
+        month: i32,
+        day: i32,
+        hr: i32,
+        min: i32,
+    ) -> Date;
+
+    /// Creates a JavaScript `Date` instance that represents
+    /// a single moment in time. `Date` objects are based on a time value that is
+    /// the number of milliseconds since 1 January 1970 UTC.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date)
+    #[wasm_bindgen(constructor)]
+    pub fn new_with_year_month_day_hr_min_sec(
+        year: u32,
+        month: i32,
+        day: i32,
+        hr: i32,
+        min: i32,
+        sec: i32,
+    ) -> Date;
+
+    /// Creates a JavaScript `Date` instance that represents
+    /// a single moment in time. `Date` objects are based on a time value that is
+    /// the number of milliseconds since 1 January 1970 UTC.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date)
+    #[wasm_bindgen(constructor)]
+    pub fn new_with_year_month_day_hr_min_sec_milli(
+        year: u32,
+        month: i32,
+        day: i32,
+        hr: i32,
+        min: i32,
+        sec: i32,
+        milli: i32,
+    ) -> Date;
+
+    /// The `Date.now()` method returns the number of milliseconds
+    /// elapsed since January 1, 1970 00:00:00 UTC.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/now)
+    #[wasm_bindgen(static_method_of = Date)]
+    pub fn now() -> f64;
+
+    /// The `Date.parse()` method parses a string representation of a date, and returns the number of milliseconds
+    /// since January 1, 1970, 00:00:00 UTC or `NaN` if the string is unrecognized or, in some cases,
+    /// contains illegal date values (e.g. 2015-02-31).
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/parse)
+    #[wasm_bindgen(static_method_of = Date)]
+    pub fn parse(date: &str) -> f64;
+
+    /// The `setDate()` method sets the day of the Date object relative to the beginning of the currently set month.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setDate)
+    #[wasm_bindgen(method, js_name = setDate)]
+    pub fn set_date(this: &Date, day: u32) -> f64;
+
+    /// The `setFullYear()` method sets the full year for a specified date according to local time.
+    /// Returns new timestamp.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setFullYear)
+    #[wasm_bindgen(method, js_name = setFullYear)]
+    pub fn set_full_year(this: &Date, year: u32) -> f64;
+
+    /// The `setFullYear()` method sets the full year for a specified date according to local time.
+    /// Returns new timestamp.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setFullYear)
+    #[wasm_bindgen(method, js_name = setFullYear)]
+    pub fn set_full_year_with_month(this: &Date, year: u32, month: i32) -> f64;
+
+    /// The `setFullYear()` method sets the full year for a specified date according to local time.
+    /// Returns new timestamp.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setFullYear)
+    #[wasm_bindgen(method, js_name = setFullYear)]
+    pub fn set_full_year_with_month_date(this: &Date, year: u32, month: i32, date: i32) -> f64;
+
+    /// The `setHours()` method sets the hours for a specified date according to local time,
+    /// and returns the number of milliseconds since January 1, 1970 00:00:00 UTC until the time represented
+    /// by the updated Date instance.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setHours)
+    #[wasm_bindgen(method, js_name = setHours)]
+    pub fn set_hours(this: &Date, hours: u32) -> f64;
+
+    /// The `setMilliseconds()` method sets the milliseconds for a specified date according to local time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMilliseconds)
+    #[wasm_bindgen(method, js_name = setMilliseconds)]
+    pub fn set_milliseconds(this: &Date, milliseconds: u32) -> f64;
+
+    /// The `setMinutes()` method sets the minutes for a specified date according to local time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMinutes)
+    #[wasm_bindgen(method, js_name = setMinutes)]
+    pub fn set_minutes(this: &Date, minutes: u32) -> f64;
+
+    /// The `setMonth()` method sets the month for a specified date according to the currently set year.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMonth)
+    #[wasm_bindgen(method, js_name = setMonth)]
+    pub fn set_month(this: &Date, month: u32) -> f64;
+
+    /// The `setSeconds()` method sets the seconds for a specified date according to local time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setSeconds)
+    #[wasm_bindgen(method, js_name = setSeconds)]
+    pub fn set_seconds(this: &Date, seconds: u32) -> f64;
+
+    /// The `setTime()` method sets the Date object to the time represented by a number of milliseconds
+    /// since January 1, 1970, 00:00:00 UTC.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setTime)
+    #[wasm_bindgen(method, js_name = setTime)]
+    pub fn set_time(this: &Date, time: f64) -> f64;
+
+    /// The `setUTCDate()` method sets the day of the month for a specified date
+    /// according to universal time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCDate)
+    #[wasm_bindgen(method, js_name = setUTCDate)]
+    pub fn set_utc_date(this: &Date, day: u32) -> f64;
+
+    /// The `setUTCFullYear()` method sets the full year for a specified date according to universal time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear)
+    #[wasm_bindgen(method, js_name = setUTCFullYear)]
+    pub fn set_utc_full_year(this: &Date, year: u32) -> f64;
+
+    /// The `setUTCFullYear()` method sets the full year for a specified date according to universal time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear)
+    #[wasm_bindgen(method, js_name = setUTCFullYear)]
+    pub fn set_utc_full_year_with_month(this: &Date, year: u32, month: i32) -> f64;
+
+    /// The `setUTCFullYear()` method sets the full year for a specified date according to universal time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear)
+    #[wasm_bindgen(method, js_name = setUTCFullYear)]
+    pub fn set_utc_full_year_with_month_date(this: &Date, year: u32, month: i32, date: i32) -> f64;
+
+    /// The `setUTCHours()` method sets the hour for a specified date according to universal time,
+    /// and returns the number of milliseconds since  January 1, 1970 00:00:00 UTC until the time
+    /// represented by the updated Date instance.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCHours)
+    #[wasm_bindgen(method, js_name = setUTCHours)]
+    pub fn set_utc_hours(this: &Date, hours: u32) -> f64;
+
+    /// The `setUTCMilliseconds()` method sets the milliseconds for a specified date
+    /// according to universal time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMilliseconds)
+    #[wasm_bindgen(method, js_name = setUTCMilliseconds)]
+    pub fn set_utc_milliseconds(this: &Date, milliseconds: u32) -> f64;
+
+    /// The `setUTCMinutes()` method sets the minutes for a specified date according to universal time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes)
+    #[wasm_bindgen(method, js_name = setUTCMinutes)]
+    pub fn set_utc_minutes(this: &Date, minutes: u32) -> f64;
+
+    /// The `setUTCMonth()` method sets the month for a specified date according to universal time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth)
+    #[wasm_bindgen(method, js_name = setUTCMonth)]
+    pub fn set_utc_month(this: &Date, month: u32) -> f64;
+
+    /// The `setUTCSeconds()` method sets the seconds for a specified date according to universal time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds)
+    #[wasm_bindgen(method, js_name = setUTCSeconds)]
+    pub fn set_utc_seconds(this: &Date, seconds: u32) -> f64;
+
+    /// The `toDateString()` method returns the date portion of a Date object
+    /// in human readable form in American English.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toDateString)
+    #[wasm_bindgen(method, js_name = toDateString)]
+    pub fn to_date_string(this: &Date) -> JsString;
+
+    /// The `toISOString()` method returns a string in simplified extended ISO format (ISO
+    /// 8601), which is always 24 or 27 characters long (YYYY-MM-DDTHH:mm:ss.sssZ or
+    /// ±YYYYYY-MM-DDTHH:mm:ss.sssZ, respectively). The timezone is always zero UTC offset,
+    /// as denoted by the suffix "Z"
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
+    #[wasm_bindgen(method, js_name = toISOString)]
+    pub fn to_iso_string(this: &Date) -> JsString;
+
+    /// The `toJSON()` method returns a string representation of the Date object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toJSON)
+    #[wasm_bindgen(method, js_name = toJSON)]
+    pub fn to_json(this: &Date) -> JsString;
+
+    /// The `toLocaleDateString()` method returns a string with a language sensitive
+    /// representation of the date portion of this date. The new locales and options
+    /// arguments let applications specify the language whose formatting conventions
+    /// should be used and allow to customize the behavior of the function.
+    /// In older implementations, which ignore the locales and options arguments,
+    /// the locale used and the form of the string
+    /// returned are entirely implementation dependent.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString)
+    #[wasm_bindgen(method, js_name = toLocaleDateString)]
+    pub fn to_locale_date_string(this: &Date, locale: &str, options: &JsValue) -> JsString;
+
+    /// The `toLocaleString()` method returns a string with a language sensitive
+    /// representation of this date. The new locales and options arguments
+    /// let applications specify the language whose formatting conventions
+    /// should be used and customize the behavior of the function.
+    /// In older implementations, which ignore the locales
+    /// and options arguments, the locale used and the form of the string
+    /// returned are entirely implementation dependent.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleString)
+    #[wasm_bindgen(method, js_name = toLocaleString)]
+    pub fn to_locale_string(this: &Date, locale: &str, options: &JsValue) -> JsString;
+
+    /// The `toLocaleTimeString()` method returns a string with a language sensitive
+    /// representation of the time portion of this date. The new locales and options
+    /// arguments let applications specify the language whose formatting conventions should be
+    /// used and customize the behavior of the function. In older implementations, which ignore
+    /// the locales and options arguments, the locale used and the form of the string
+    /// returned are entirely implementation dependent.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString)
+    #[wasm_bindgen(method, js_name = toLocaleTimeString)]
+    pub fn to_locale_time_string(this: &Date, locale: &str) -> JsString;
+
+    /// The `toString()` method returns a string representing
+    /// the specified Date object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toString)
+    #[wasm_bindgen(method, js_name = toString)]
+    pub fn to_string(this: &Date) -> JsString;
+
+    /// The `toTimeString()` method returns the time portion of a Date object in human
+    /// readable form in American English.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toTimeString)
+    #[wasm_bindgen(method, js_name = toTimeString)]
+    pub fn to_time_string(this: &Date) -> JsString;
+
+    /// The `toUTCString()` method converts a date to a string,
+    /// using the UTC time zone.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toUTCString)
+    #[wasm_bindgen(method, js_name = toUTCString)]
+    pub fn to_utc_string(this: &Date) -> JsString;
+
+    /// The `Date.UTC()` method accepts the same parameters as the
+    /// longest form of the constructor, and returns the number of
+    /// milliseconds in a `Date` object since January 1, 1970,
+    /// 00:00:00, universal time.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/UTC)
+    #[wasm_bindgen(static_method_of = Date, js_name = UTC)]
+    pub fn utc(year: f64, month: f64) -> f64;
+
+    /// The `valueOf()` method  returns the primitive value of
+    /// a Date object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/valueOf)
+    #[wasm_bindgen(method, js_name = valueOf)]
+    pub fn value_of(this: &Date) -> f64;
+}
+
+// Object.
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(typescript_type = "object")]
+    #[derive(Clone, Debug)]
+    pub type Object;
+
+    /// The `Object.assign()` method is used to copy the values of all enumerable
+    /// own properties from one or more source objects to a target object. It
+    /// will return the target object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)
+    #[wasm_bindgen(static_method_of = Object)]
+    pub fn assign(target: &Object, source: &Object) -> Object;
+
+    /// The `Object.assign()` method is used to copy the values of all enumerable
+    /// own properties from one or more source objects to a target object. It
+    /// will return the target object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)
+    #[wasm_bindgen(static_method_of = Object, js_name = assign)]
+    pub fn assign2(target: &Object, source1: &Object, source2: &Object) -> Object;
+
+    /// The `Object.assign()` method is used to copy the values of all enumerable
+    /// own properties from one or more source objects to a target object. It
+    /// will return the target object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)
+    #[wasm_bindgen(static_method_of = Object, js_name = assign)]
+    pub fn assign3(target: &Object, source1: &Object, source2: &Object, source3: &Object)
+        -> Object;
+
+    /// The constructor property returns a reference to the `Object` constructor
+    /// function that created the instance object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor)
+    #[wasm_bindgen(method, getter)]
+    pub fn constructor(this: &Object) -> Function;
+
+    /// The `Object.create()` method creates a new object, using an existing
+    /// object to provide the newly created object's prototype.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create)
+    #[wasm_bindgen(static_method_of = Object)]
+    pub fn create(prototype: &Object) -> Object;
+
+    /// The static method `Object.defineProperty()` defines a new
+    /// property directly on an object, or modifies an existing
+    /// property on an object, and returns the object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty)
+    #[wasm_bindgen(static_method_of = Object, js_name = defineProperty)]
+    pub fn define_property(obj: &Object, prop: &JsValue, descriptor: &Object) -> Object;
+
+    /// The `Object.defineProperties()` method defines new or modifies
+    /// existing properties directly on an object, returning the
+    /// object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperties)
+    #[wasm_bindgen(static_method_of = Object, js_name = defineProperties)]
+    pub fn define_properties(obj: &Object, props: &Object) -> Object;
+
+    /// The `Object.entries()` method returns an array of a given
+    /// object's own enumerable property [key, value] pairs, in the
+    /// same order as that provided by a for...in loop (the difference
+    /// being that a for-in loop enumerates properties in the
+    /// prototype chain as well).
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries)
+    #[wasm_bindgen(static_method_of = Object)]
+    pub fn entries(object: &Object) -> Array;
+
+    /// The `Object.freeze()` method freezes an object: that is, prevents new
+    /// properties from being added to it; prevents existing properties from
+    /// being removed; and prevents existing properties, or their enumerability,
+    /// configurability, or writability, from being changed, it also prevents
+    /// the prototype from being changed. The method returns the passed object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze)
+    #[wasm_bindgen(static_method_of = Object)]
+    pub fn freeze(value: &Object) -> Object;
+
+    /// The `Object.fromEntries()` method transforms a list of key-value pairs
+    /// into an object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/fromEntries)
+    #[wasm_bindgen(static_method_of = Object, catch, js_name = fromEntries)]
+    pub fn from_entries(iterable: &JsValue) -> Result<Object, JsValue>;
+
+    /// The `Object.getOwnPropertyDescriptor()` method returns a
+    /// property descriptor for an own property (that is, one directly
+    /// present on an object and not in the object's prototype chain)
+    /// of a given object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor)
+    #[wasm_bindgen(static_method_of = Object, js_name = getOwnPropertyDescriptor)]
+    pub fn get_own_property_descriptor(obj: &Object, prop: &JsValue) -> JsValue;
+
+    /// The `Object.getOwnPropertyDescriptors()` method returns all own
+    /// property descriptors of a given object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptors)
+    #[wasm_bindgen(static_method_of = Object, js_name = getOwnPropertyDescriptors)]
+    pub fn get_own_property_descriptors(obj: &Object) -> JsValue;
+
+    /// The `Object.getOwnPropertyNames()` method returns an array of
+    /// all properties (including non-enumerable properties except for
+    /// those which use Symbol) found directly upon a given object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames)
+    #[wasm_bindgen(static_method_of = Object, js_name = getOwnPropertyNames)]
+    pub fn get_own_property_names(obj: &Object) -> Array;
+
+    /// The `Object.getOwnPropertySymbols()` method returns an array of
+    /// all symbol properties found directly upon a given object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertySymbols)
+    #[wasm_bindgen(static_method_of = Object, js_name = getOwnPropertySymbols)]
+    pub fn get_own_property_symbols(obj: &Object) -> Array;
+
+    /// The `Object.getPrototypeOf()` method returns the prototype
+    /// (i.e. the value of the internal [[Prototype]] property) of the
+    /// specified object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf)
+    #[wasm_bindgen(static_method_of = Object, js_name = getPrototypeOf)]
+    pub fn get_prototype_of(obj: &JsValue) -> Object;
+
+    /// The `hasOwnProperty()` method returns a boolean indicating whether the
+    /// object has the specified property as its own property (as opposed to
+    /// inheriting it).
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty)
+    #[wasm_bindgen(method, js_name = hasOwnProperty)]
+    pub fn has_own_property(this: &Object, property: &JsValue) -> bool;
+
+    /// The `Object.hasOwn()` method returns a boolean indicating whether the
+    /// object passed in has the specified property as its own property (as
+    /// opposed to inheriting it).
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn)
+    #[wasm_bindgen(static_method_of = Object, js_name = hasOwn)]
+    pub fn has_own(instance: &Object, property: &JsValue) -> bool;
+
+    /// The `Object.is()` method determines whether two values are the same value.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is)
+    #[wasm_bindgen(static_method_of = Object)]
+    pub fn is(value_1: &JsValue, value_2: &JsValue) -> bool;
+
+    /// The `Object.isExtensible()` method determines if an object is extensible
+    /// (whether it can have new properties added to it).
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isExtensible)
+    #[wasm_bindgen(static_method_of = Object, js_name = isExtensible)]
+    pub fn is_extensible(object: &Object) -> bool;
+
+    /// The `Object.isFrozen()` determines if an object is frozen.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isFrozen)
+    #[wasm_bindgen(static_method_of = Object, js_name = isFrozen)]
+    pub fn is_frozen(object: &Object) -> bool;
+
+    /// The `Object.isSealed()` method determines if an object is sealed.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isSealed)
+    #[wasm_bindgen(static_method_of = Object, js_name = isSealed)]
+    pub fn is_sealed(object: &Object) -> bool;
+
+    /// The `isPrototypeOf()` method checks if an object exists in another
+    /// object's prototype chain.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isPrototypeOf)
+    #[wasm_bindgen(method, js_name = isPrototypeOf)]
+    pub fn is_prototype_of(this: &Object, value: &JsValue) -> bool;
+
+    /// The `Object.keys()` method returns an array of a given object's property
+    /// names, in the same order as we get with a normal loop.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys)
+    #[wasm_bindgen(static_method_of = Object)]
+    pub fn keys(object: &Object) -> Array;
+
+    /// The [`Object`] constructor creates an object wrapper.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Object;
+
+    /// The `Object.preventExtensions()` method prevents new properties from
+    /// ever being added to an object (i.e. prevents future extensions to the
+    /// object).
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/preventExtensions)
+    #[wasm_bindgen(static_method_of = Object, js_name = preventExtensions)]
+    pub fn prevent_extensions(object: &Object);
+
+    /// The `propertyIsEnumerable()` method returns a Boolean indicating
+    /// whether the specified property is enumerable.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/propertyIsEnumerable)
+    #[wasm_bindgen(method, js_name = propertyIsEnumerable)]
+    pub fn property_is_enumerable(this: &Object, property: &JsValue) -> bool;
+
+    /// The `Object.seal()` method seals an object, preventing new properties
+    /// from being added to it and marking all existing properties as
+    /// non-configurable.  Values of present properties can still be changed as
+    /// long as they are writable.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/seal)
+    #[wasm_bindgen(static_method_of = Object)]
+    pub fn seal(value: &Object) -> Object;
+
+    /// The `Object.setPrototypeOf()` method sets the prototype (i.e., the
+    /// internal `[[Prototype]]` property) of a specified object to another
+    /// object or `null`.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf)
+    #[wasm_bindgen(static_method_of = Object, js_name = setPrototypeOf)]
+    pub fn set_prototype_of(object: &Object, prototype: &Object) -> Object;
+
+    /// The `toLocaleString()` method returns a string representing the object.
+    /// This method is meant to be overridden by derived objects for
+    /// locale-specific purposes.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toLocaleString)
+    #[wasm_bindgen(method, js_name = toLocaleString)]
+    pub fn to_locale_string(this: &Object) -> JsString;
+
+    /// The `toString()` method returns a string representing the object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString)
+    #[wasm_bindgen(method, js_name = toString)]
+    pub fn to_string(this: &Object) -> JsString;
+
+    /// The `valueOf()` method returns the primitive value of the
+    /// specified object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/valueOf)
+    #[wasm_bindgen(method, js_name = valueOf)]
+    pub fn value_of(this: &Object) -> Object;
+
+    /// The `Object.values()` method returns an array of a given object's own
+    /// enumerable property values, in the same order as that provided by a
+    /// `for...in` loop (the difference being that a for-in loop enumerates
+    /// properties in the prototype chain as well).
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/values)
+    #[wasm_bindgen(static_method_of = Object)]
+    pub fn values(object: &Object) -> Array;
+}
+
+impl Object {
+    /// Returns the `Object` value of this JS value if it's an instance of an
+    /// object.
+    ///
+    /// If this JS value is not an instance of an object then this returns
+    /// `None`.
+    pub fn try_from(val: &JsValue) -> Option<&Object> {
+        if val.is_object() {
+            Some(val.unchecked_ref())
+        } else {
+            None
+        }
+    }
+}
+
+impl PartialEq for Object {
+    #[inline]
+    fn eq(&self, other: &Object) -> bool {
+        Object::is(self.as_ref(), other.as_ref())
+    }
+}
+
+impl Eq for Object {}
+
+impl Default for Object {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+// Proxy
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(typescript_type = "ProxyConstructor")]
+    #[derive(Clone, Debug)]
+    pub type Proxy;
+
+    /// The [`Proxy`] object is used to define custom behavior for fundamental
+    /// operations (e.g. property lookup, assignment, enumeration, function
+    /// invocation, etc).
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy)
+    #[wasm_bindgen(constructor)]
+    pub fn new(target: &JsValue, handler: &Object) -> Proxy;
+
+    /// The `Proxy.revocable()` method is used to create a revocable [`Proxy`]
+    /// object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/revocable)
+    #[wasm_bindgen(static_method_of = Proxy)]
+    pub fn revocable(target: &JsValue, handler: &Object) -> Object;
+}
+
+// RangeError
+#[wasm_bindgen]
+extern "C" {
+    /// The `RangeError` object indicates an error when a value is not in the set
+    /// or range of allowed values.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError)
+    #[wasm_bindgen(extends = Error, extends = Object, typescript_type = "RangeError")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type RangeError;
+
+    /// The `RangeError` object indicates an error when a value is not in the set
+    /// or range of allowed values.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError)
+    #[wasm_bindgen(constructor)]
+    pub fn new(message: &str) -> RangeError;
+}
+
+// ReferenceError
+#[wasm_bindgen]
+extern "C" {
+    /// The `ReferenceError` object represents an error when a non-existent
+    /// variable is referenced.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError)
+    #[wasm_bindgen(extends = Error, extends = Object, typescript_type = "ReferenceError")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type ReferenceError;
+
+    /// The `ReferenceError` object represents an error when a non-existent
+    /// variable is referenced.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError)
+    #[wasm_bindgen(constructor)]
+    pub fn new(message: &str) -> ReferenceError;
+}
+
+#[allow(non_snake_case)]
+pub mod Reflect {
+    use super::*;
+
+    // Reflect
+    #[wasm_bindgen]
+    extern "C" {
+        /// The static `Reflect.apply()` method calls a target function with
+        /// arguments as specified.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/apply)
+        #[wasm_bindgen(js_namespace = Reflect, catch)]
+        pub fn apply(
+            target: &Function,
+            this_argument: &JsValue,
+            arguments_list: &Array,
+        ) -> Result<JsValue, JsValue>;
+
+        /// The static `Reflect.construct()` method acts like the new operator, but
+        /// as a function.  It is equivalent to calling `new target(...args)`. It
+        /// gives also the added option to specify a different prototype.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/construct)
+        #[wasm_bindgen(js_namespace = Reflect, catch)]
+        pub fn construct(target: &Function, arguments_list: &Array) -> Result<JsValue, JsValue>;
+
+        /// The static `Reflect.construct()` method acts like the new operator, but
+        /// as a function.  It is equivalent to calling `new target(...args)`. It
+        /// gives also the added option to specify a different prototype.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/construct)
+        #[wasm_bindgen(js_namespace = Reflect, js_name = construct, catch)]
+        pub fn construct_with_new_target(
+            target: &Function,
+            arguments_list: &Array,
+            new_target: &Function,
+        ) -> Result<JsValue, JsValue>;
+
+        /// The static `Reflect.defineProperty()` method is like
+        /// `Object.defineProperty()` but returns a `Boolean`.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/defineProperty)
+        #[wasm_bindgen(js_namespace = Reflect, js_name = defineProperty, catch)]
+        pub fn define_property(
+            target: &Object,
+            property_key: &JsValue,
+            attributes: &Object,
+        ) -> Result<bool, JsValue>;
+
+        /// The static `Reflect.deleteProperty()` method allows to delete
+        /// properties.  It is like the `delete` operator as a function.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/deleteProperty)
+        #[wasm_bindgen(js_namespace = Reflect, js_name = deleteProperty, catch)]
+        pub fn delete_property(target: &Object, key: &JsValue) -> Result<bool, JsValue>;
+
+        /// The static `Reflect.get()` method works like getting a property from
+        /// an object (`target[propertyKey]`) as a function.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/get)
+        #[wasm_bindgen(js_namespace = Reflect, catch)]
+        pub fn get(target: &JsValue, key: &JsValue) -> Result<JsValue, JsValue>;
+
+        /// The same as [`get`](fn.get.html)
+        /// except the key is an `f64`, which is slightly faster.
+        #[wasm_bindgen(js_namespace = Reflect, js_name = "get", catch)]
+        pub fn get_f64(target: &JsValue, key: f64) -> Result<JsValue, JsValue>;
+
+        /// The same as [`get`](fn.get.html)
+        /// except the key is a `u32`, which is slightly faster.
+        #[wasm_bindgen(js_namespace = Reflect, js_name = "get", catch)]
+        pub fn get_u32(target: &JsValue, key: u32) -> Result<JsValue, JsValue>;
+
+        /// The static `Reflect.getOwnPropertyDescriptor()` method is similar to
+        /// `Object.getOwnPropertyDescriptor()`. It returns a property descriptor
+        /// of the given property if it exists on the object, `undefined` otherwise.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/getOwnPropertyDescriptor)
+        #[wasm_bindgen(js_namespace = Reflect, js_name = getOwnPropertyDescriptor, catch)]
+        pub fn get_own_property_descriptor(
+            target: &Object,
+            property_key: &JsValue,
+        ) -> Result<JsValue, JsValue>;
+
+        /// The static `Reflect.getPrototypeOf()` method is almost the same
+        /// method as `Object.getPrototypeOf()`. It returns the prototype
+        /// (i.e. the value of the internal `[[Prototype]]` property) of
+        /// the specified object.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/getPrototypeOf)
+        #[wasm_bindgen(js_namespace = Reflect, js_name = getPrototypeOf, catch)]
+        pub fn get_prototype_of(target: &JsValue) -> Result<Object, JsValue>;
+
+        /// The static `Reflect.has()` method works like the in operator as a
+        /// function.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/has)
+        #[wasm_bindgen(js_namespace = Reflect, catch)]
+        pub fn has(target: &JsValue, property_key: &JsValue) -> Result<bool, JsValue>;
+
+        /// The static `Reflect.isExtensible()` method determines if an object is
+        /// extensible (whether it can have new properties added to it). It is
+        /// similar to `Object.isExtensible()`, but with some differences.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/isExtensible)
+        #[wasm_bindgen(js_namespace = Reflect, js_name = isExtensible, catch)]
+        pub fn is_extensible(target: &Object) -> Result<bool, JsValue>;
+
+        /// The static `Reflect.ownKeys()` method returns an array of the
+        /// target object's own property keys.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/ownKeys)
+        #[wasm_bindgen(js_namespace = Reflect, js_name = ownKeys, catch)]
+        pub fn own_keys(target: &JsValue) -> Result<Array, JsValue>;
+
+        /// The static `Reflect.preventExtensions()` method prevents new
+        /// properties from ever being added to an object (i.e. prevents
+        /// future extensions to the object). It is similar to
+        /// `Object.preventExtensions()`, but with some differences.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/preventExtensions)
+        #[wasm_bindgen(js_namespace = Reflect, js_name = preventExtensions, catch)]
+        pub fn prevent_extensions(target: &Object) -> Result<bool, JsValue>;
+
+        /// The static `Reflect.set()` method works like setting a
+        /// property on an object.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/set)
+        #[wasm_bindgen(js_namespace = Reflect, catch)]
+        pub fn set(
+            target: &JsValue,
+            property_key: &JsValue,
+            value: &JsValue,
+        ) -> Result<bool, JsValue>;
+
+        /// The same as [`set`](fn.set.html)
+        /// except the key is an `f64`, which is slightly faster.
+        #[wasm_bindgen(js_namespace = Reflect, js_name = "set", catch)]
+        pub fn set_f64(
+            target: &JsValue,
+            property_key: f64,
+            value: &JsValue,
+        ) -> Result<bool, JsValue>;
+
+        /// The same as [`set`](fn.set.html)
+        /// except the key is a `u32`, which is slightly faster.
+        #[wasm_bindgen(js_namespace = Reflect, js_name = "set", catch)]
+        pub fn set_u32(
+            target: &JsValue,
+            property_key: u32,
+            value: &JsValue,
+        ) -> Result<bool, JsValue>;
+
+        /// The static `Reflect.set()` method works like setting a
+        /// property on an object.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/set)
+        #[wasm_bindgen(js_namespace = Reflect, js_name = set, catch)]
+        pub fn set_with_receiver(
+            target: &JsValue,
+            property_key: &JsValue,
+            value: &JsValue,
+            receiver: &JsValue,
+        ) -> Result<bool, JsValue>;
+
+        /// The static `Reflect.setPrototypeOf()` method is the same
+        /// method as `Object.setPrototypeOf()`. It sets the prototype
+        /// (i.e., the internal `[[Prototype]]` property) of a specified
+        /// object to another object or to null.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/setPrototypeOf)
+        #[wasm_bindgen(js_namespace = Reflect, js_name = setPrototypeOf, catch)]
+        pub fn set_prototype_of(target: &Object, prototype: &JsValue) -> Result<bool, JsValue>;
+    }
+}
+
+// RegExp
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(extends = Object, typescript_type = "RegExp")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type RegExp;
+
+    /// The `exec()` method executes a search for a match in a specified
+    /// string. Returns a result array, or null.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec)
+    #[wasm_bindgen(method)]
+    pub fn exec(this: &RegExp, text: &str) -> Option<Array>;
+
+    /// The flags property returns a string consisting of the flags of
+    /// the current regular expression object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/flags)
+    #[wasm_bindgen(method, getter)]
+    pub fn flags(this: &RegExp) -> JsString;
+
+    /// The global property indicates whether or not the "g" flag is
+    /// used with the regular expression. global is a read-only
+    /// property of an individual regular expression instance.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/global)
+    #[wasm_bindgen(method, getter)]
+    pub fn global(this: &RegExp) -> bool;
+
+    /// The ignoreCase property indicates whether or not the "i" flag
+    /// is used with the regular expression. ignoreCase is a read-only
+    /// property of an individual regular expression instance.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/ignoreCase)
+    #[wasm_bindgen(method, getter, js_name = ignoreCase)]
+    pub fn ignore_case(this: &RegExp) -> bool;
+
+    /// The non-standard input property is a static property of
+    /// regular expressions that contains the string against which a
+    /// regular expression is matched. RegExp.$_ is an alias for this
+    /// property.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/input)
+    #[wasm_bindgen(static_method_of = RegExp, getter)]
+    pub fn input() -> JsString;
+
+    /// The lastIndex is a read/write integer property of regular expression
+    /// instances that specifies the index at which to start the next match.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/lastIndex)
+    #[wasm_bindgen(structural, getter = lastIndex, method)]
+    pub fn last_index(this: &RegExp) -> u32;
+
+    /// The lastIndex is a read/write integer property of regular expression
+    /// instances that specifies the index at which to start the next match.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/lastIndex)
+    #[wasm_bindgen(structural, setter = lastIndex, method)]
+    pub fn set_last_index(this: &RegExp, index: u32);
+
+    /// The non-standard lastMatch property is a static and read-only
+    /// property of regular expressions that contains the last matched
+    /// characters. `RegExp.$&` is an alias for this property.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/lastMatch)
+    #[wasm_bindgen(static_method_of = RegExp, getter, js_name = lastMatch)]
+    pub fn last_match() -> JsString;
+
+    /// The non-standard lastParen property is a static and read-only
+    /// property of regular expressions that contains the last
+    /// parenthesized substring match, if any. `RegExp.$+` is an alias
+    /// for this property.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/lastParen)
+    #[wasm_bindgen(static_method_of = RegExp, getter, js_name = lastParen)]
+    pub fn last_paren() -> JsString;
+
+    /// The non-standard leftContext property is a static and
+    /// read-only property of regular expressions that contains the
+    /// substring preceding the most recent match. `RegExp.$`` is an
+    /// alias for this property.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/leftContext)
+    #[wasm_bindgen(static_method_of = RegExp, getter, js_name = leftContext)]
+    pub fn left_context() -> JsString;
+
+    /// The multiline property indicates whether or not the "m" flag
+    /// is used with the regular expression. multiline is a read-only
+    /// property of an individual regular expression instance.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/multiline)
+    #[wasm_bindgen(method, getter)]
+    pub fn multiline(this: &RegExp) -> bool;
+
+    /// The non-standard $1, $2, $3, $4, $5, $6, $7, $8, $9 properties
+    /// are static and read-only properties of regular expressions
+    /// that contain parenthesized substring matches.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/n)
+    #[wasm_bindgen(static_method_of = RegExp, getter, js_name = "$1")]
+    pub fn n1() -> JsString;
+    #[wasm_bindgen(static_method_of = RegExp, getter, js_name = "$2")]
+    pub fn n2() -> JsString;
+    #[wasm_bindgen(static_method_of = RegExp, getter, js_name = "$3")]
+    pub fn n3() -> JsString;
+    #[wasm_bindgen(static_method_of = RegExp, getter, js_name = "$4")]
+    pub fn n4() -> JsString;
+    #[wasm_bindgen(static_method_of = RegExp, getter, js_name = "$5")]
+    pub fn n5() -> JsString;
+    #[wasm_bindgen(static_method_of = RegExp, getter, js_name = "$6")]
+    pub fn n6() -> JsString;
+    #[wasm_bindgen(static_method_of = RegExp, getter, js_name = "$7")]
+    pub fn n7() -> JsString;
+    #[wasm_bindgen(static_method_of = RegExp, getter, js_name = "$8")]
+    pub fn n8() -> JsString;
+    #[wasm_bindgen(static_method_of = RegExp, getter, js_name = "$9")]
+    pub fn n9() -> JsString;
+
+    /// The `RegExp` constructor creates a regular expression object for matching text with a pattern.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp)
+    #[wasm_bindgen(constructor)]
+    pub fn new(pattern: &str, flags: &str) -> RegExp;
+    #[wasm_bindgen(constructor)]
+    pub fn new_regexp(pattern: &RegExp, flags: &str) -> RegExp;
+
+    /// The non-standard rightContext property is a static and
+    /// read-only property of regular expressions that contains the
+    /// substring following the most recent match. `RegExp.$'` is an
+    /// alias for this property.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/rightContext)
+    #[wasm_bindgen(static_method_of = RegExp, getter, js_name = rightContext)]
+    pub fn right_context() -> JsString;
+
+    /// The source property returns a String containing the source
+    /// text of the regexp object, and it doesn't contain the two
+    /// forward slashes on both sides and any flags.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/source)
+    #[wasm_bindgen(method, getter)]
+    pub fn source(this: &RegExp) -> JsString;
+
+    /// The sticky property reflects whether or not the search is
+    /// sticky (searches in strings only from the index indicated by
+    /// the lastIndex property of this regular expression). sticky is
+    /// a read-only property of an individual regular expression
+    /// object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/sticky)
+    #[wasm_bindgen(method, getter)]
+    pub fn sticky(this: &RegExp) -> bool;
+
+    /// The `test()` method executes a search for a match between a
+    /// regular expression and a specified string. Returns true or
+    /// false.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/test)
+    #[wasm_bindgen(method)]
+    pub fn test(this: &RegExp, text: &str) -> bool;
+
+    /// The `toString()` method returns a string representing the
+    /// regular expression.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/toString)
+    #[wasm_bindgen(method, js_name = toString)]
+    pub fn to_string(this: &RegExp) -> JsString;
+
+    /// The unicode property indicates whether or not the "u" flag is
+    /// used with a regular expression. unicode is a read-only
+    /// property of an individual regular expression instance.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/unicode)
+    #[wasm_bindgen(method, getter)]
+    pub fn unicode(this: &RegExp) -> bool;
+}
+
+// Set
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(extends = Object, typescript_type = "Set<any>")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type Set;
+
+    /// The `add()` method appends a new element with a specified value to the
+    /// end of a [`Set`] object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/add)
+    #[wasm_bindgen(method)]
+    pub fn add(this: &Set, value: &JsValue) -> Set;
+
+    /// The `clear()` method removes all elements from a [`Set`] object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/clear)
+    #[wasm_bindgen(method)]
+    pub fn clear(this: &Set);
+
+    /// The `delete()` method removes the specified element from a [`Set`]
+    /// object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/delete)
+    #[wasm_bindgen(method)]
+    pub fn delete(this: &Set, value: &JsValue) -> bool;
+
+    /// The `forEach()` method executes a provided function once for each value
+    /// in the Set object, in insertion order.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/forEach)
+    #[wasm_bindgen(method, js_name = forEach)]
+    pub fn for_each(this: &Set, callback: &mut dyn FnMut(JsValue, JsValue, Set));
+
+    /// The `has()` method returns a boolean indicating whether an element with
+    /// the specified value exists in a [`Set`] object or not.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/has)
+    #[wasm_bindgen(method)]
+    pub fn has(this: &Set, value: &JsValue) -> bool;
+
+    /// The [`Set`] object lets you store unique values of any type, whether
+    /// primitive values or object references.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set)
+    #[wasm_bindgen(constructor)]
+    pub fn new(init: &JsValue) -> Set;
+
+    /// The size accessor property returns the number of elements in a [`Set`]
+    /// object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/Set/size)
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn size(this: &Set) -> u32;
+}
+
+impl Default for Set {
+    fn default() -> Self {
+        Self::new(&JsValue::UNDEFINED)
+    }
+}
+
+// SetIterator
+#[wasm_bindgen]
+extern "C" {
+    /// The `entries()` method returns a new Iterator object that contains an
+    /// array of [value, value] for each element in the Set object, in insertion
+    /// order. For Set objects there is no key like in Map objects. However, to
+    /// keep the API similar to the Map object, each entry has the same value
+    /// for its key and value here, so that an array [value, value] is returned.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/entries)
+    #[wasm_bindgen(method)]
+    pub fn entries(set: &Set) -> Iterator;
+
+    /// The `keys()` method is an alias for this method (for similarity with
+    /// Map objects); it behaves exactly the same and returns values
+    /// of Set elements.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/values)
+    #[wasm_bindgen(method)]
+    pub fn keys(set: &Set) -> Iterator;
+
+    /// The `values()` method returns a new Iterator object that contains the
+    /// values for each element in the Set object in insertion order.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/values)
+    #[wasm_bindgen(method)]
+    pub fn values(set: &Set) -> Iterator;
+}
+
+// SyntaxError
+#[wasm_bindgen]
+extern "C" {
+    /// A `SyntaxError` is thrown when the JavaScript engine encounters tokens or
+    /// token order that does not conform to the syntax of the language when
+    /// parsing code.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError)
+    #[wasm_bindgen(extends = Error, extends = Object, typescript_type = "SyntaxError")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type SyntaxError;
+
+    /// A `SyntaxError` is thrown when the JavaScript engine encounters tokens or
+    /// token order that does not conform to the syntax of the language when
+    /// parsing code.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError)
+    #[wasm_bindgen(constructor)]
+    pub fn new(message: &str) -> SyntaxError;
+}
+
+// TypeError
+#[wasm_bindgen]
+extern "C" {
+    /// The `TypeError` object represents an error when a value is not of the
+    /// expected type.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError)
+    #[wasm_bindgen(extends = Error, extends = Object, typescript_type = "TypeError")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type TypeError;
+
+    /// The `TypeError` object represents an error when a value is not of the
+    /// expected type.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError)
+    #[wasm_bindgen(constructor)]
+    pub fn new(message: &str) -> TypeError;
+}
+
+// URIError
+#[wasm_bindgen]
+extern "C" {
+    /// The `URIError` object represents an error when a global URI handling
+    /// function was used in a wrong way.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError)
+    #[wasm_bindgen(extends = Error, extends = Object, js_name = URIError, typescript_type = "URIError")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type UriError;
+
+    /// The `URIError` object represents an error when a global URI handling
+    /// function was used in a wrong way.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError)
+    #[wasm_bindgen(constructor, js_class = "URIError")]
+    pub fn new(message: &str) -> UriError;
+}
+
+// WeakMap
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(extends = Object, typescript_type = "WeakMap<object, any>")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type WeakMap;
+
+    /// The [`WeakMap`] object is a collection of key/value pairs in which the
+    /// keys are weakly referenced.  The keys must be objects and the values can
+    /// be arbitrary values.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap)
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> WeakMap;
+
+    /// The `set()` method sets the value for the key in the [`WeakMap`] object.
+    /// Returns the [`WeakMap`] object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap/set)
+    #[wasm_bindgen(method, js_class = "WeakMap")]
+    pub fn set(this: &WeakMap, key: &Object, value: &JsValue) -> WeakMap;
+
+    /// The `get()` method returns a specified by key element
+    /// from a [`WeakMap`] object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap/get)
+    #[wasm_bindgen(method)]
+    pub fn get(this: &WeakMap, key: &Object) -> JsValue;
+
+    /// The `has()` method returns a boolean indicating whether an element with
+    /// the specified key exists in the [`WeakMap`] object or not.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap/has)
+    #[wasm_bindgen(method)]
+    pub fn has(this: &WeakMap, key: &Object) -> bool;
+
+    /// The `delete()` method removes the specified element from a [`WeakMap`]
+    /// object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap/delete)
+    #[wasm_bindgen(method)]
+    pub fn delete(this: &WeakMap, key: &Object) -> bool;
+}
+
+impl Default for WeakMap {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+// WeakSet
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(extends = Object, typescript_type = "WeakSet<object>")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type WeakSet;
+
+    /// The `WeakSet` object lets you store weakly held objects in a collection.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet)
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> WeakSet;
+
+    /// The `has()` method returns a boolean indicating whether an object exists
+    /// in a WeakSet or not.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet/has)
+    #[wasm_bindgen(method)]
+    pub fn has(this: &WeakSet, value: &Object) -> bool;
+
+    /// The `add()` method appends a new object to the end of a WeakSet object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet/add)
+    #[wasm_bindgen(method)]
+    pub fn add(this: &WeakSet, value: &Object) -> WeakSet;
+
+    /// The `delete()` method removes the specified element from a WeakSet
+    /// object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet/delete)
+    #[wasm_bindgen(method)]
+    pub fn delete(this: &WeakSet, value: &Object) -> bool;
+}
+
+impl Default for WeakSet {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(js_sys_unstable_apis)]
+#[allow(non_snake_case)]
+pub mod Temporal;
+
+#[allow(non_snake_case)]
+pub mod WebAssembly {
+    use super::*;
+
+    // WebAssembly
+    #[wasm_bindgen]
+    extern "C" {
+        /// The `WebAssembly.compile()` function compiles a `WebAssembly.Module`
+        /// from WebAssembly binary code.  This function is useful if it is
+        /// necessary to a compile a module before it can be instantiated
+        /// (otherwise, the `WebAssembly.instantiate()` function should be used).
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/compile)
+        #[wasm_bindgen(js_namespace = WebAssembly)]
+        pub fn compile(buffer_source: &JsValue) -> Promise;
+
+        /// The `WebAssembly.compileStreaming()` function compiles a
+        /// `WebAssembly.Module` module directly from a streamed underlying
+        /// source. This function is useful if it is necessary to a compile a
+        /// module before it can be instantiated (otherwise, the
+        /// `WebAssembly.instantiateStreaming()` function should be used).
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/compileStreaming)
+        #[wasm_bindgen(js_namespace = WebAssembly, js_name = compileStreaming)]
+        pub fn compile_streaming(response: &Promise) -> Promise;
+
+        /// The `WebAssembly.instantiate()` function allows you to compile and
+        /// instantiate WebAssembly code.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate)
+        #[wasm_bindgen(js_namespace = WebAssembly, js_name = instantiate)]
+        pub fn instantiate_buffer(buffer: &[u8], imports: &Object) -> Promise;
+
+        /// The `WebAssembly.instantiate()` function allows you to compile and
+        /// instantiate WebAssembly code.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate)
+        #[wasm_bindgen(js_namespace = WebAssembly, js_name = instantiate)]
+        pub fn instantiate_module(module: &Module, imports: &Object) -> Promise;
+
+        /// The `WebAssembly.instantiateStreaming()` function compiles and
+        /// instantiates a WebAssembly module directly from a streamed
+        /// underlying source. This is the most efficient, optimized way to load
+        /// wasm code.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiateStreaming)
+        #[wasm_bindgen(js_namespace = WebAssembly, js_name = instantiateStreaming)]
+        pub fn instantiate_streaming(response: &Promise, imports: &Object) -> Promise;
+
+        /// The `WebAssembly.validate()` function validates a given typed
+        /// array of WebAssembly binary code, returning whether the bytes
+        /// form a valid wasm module (`true`) or not (`false`).
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/validate)
+        #[wasm_bindgen(js_namespace = WebAssembly, catch)]
+        pub fn validate(buffer_source: &JsValue) -> Result<bool, JsValue>;
+    }
+
+    // WebAssembly.CompileError
+    #[wasm_bindgen]
+    extern "C" {
+        /// The `WebAssembly.CompileError()` constructor creates a new
+        /// WebAssembly `CompileError` object, which indicates an error during
+        /// WebAssembly decoding or validation.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/CompileError)
+        #[wasm_bindgen(extends = Error, js_namespace = WebAssembly, typescript_type = "WebAssembly.CompileError")]
+        #[derive(Clone, Debug, PartialEq, Eq)]
+        pub type CompileError;
+
+        /// The `WebAssembly.CompileError()` constructor creates a new
+        /// WebAssembly `CompileError` object, which indicates an error during
+        /// WebAssembly decoding or validation.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/CompileError)
+        #[wasm_bindgen(constructor, js_namespace = WebAssembly)]
+        pub fn new(message: &str) -> CompileError;
+    }
+
+    // WebAssembly.Instance
+    #[wasm_bindgen]
+    extern "C" {
+        /// A `WebAssembly.Instance` object is a stateful, executable instance
+        /// of a `WebAssembly.Module`. Instance objects contain all the exported
+        /// WebAssembly functions that allow calling into WebAssembly code from
+        /// JavaScript.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance)
+        #[wasm_bindgen(extends = Object, js_namespace = WebAssembly, typescript_type = "WebAssembly.Instance")]
+        #[derive(Clone, Debug, PartialEq, Eq)]
+        pub type Instance;
+
+        /// The `WebAssembly.Instance()` constructor function can be called to
+        /// synchronously instantiate a given `WebAssembly.Module`
+        /// object. However, the primary way to get an `Instance` is through the
+        /// asynchronous `WebAssembly.instantiateStreaming()` function.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance)
+        #[wasm_bindgen(catch, constructor, js_namespace = WebAssembly)]
+        pub fn new(module: &Module, imports: &Object) -> Result<Instance, JsValue>;
+
+        /// The `exports` readonly property of the `WebAssembly.Instance` object
+        /// prototype returns an object containing as its members all the
+        /// functions exported from the WebAssembly module instance, to allow
+        /// them to be accessed and used by JavaScript.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance/exports)
+        #[wasm_bindgen(getter, method, js_namespace = WebAssembly)]
+        pub fn exports(this: &Instance) -> Object;
+    }
+
+    // WebAssembly.LinkError
+    #[wasm_bindgen]
+    extern "C" {
+        /// The `WebAssembly.LinkError()` constructor creates a new WebAssembly
+        /// LinkError object, which indicates an error during module
+        /// instantiation (besides traps from the start function).
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/LinkError)
+        #[wasm_bindgen(extends = Error, js_namespace = WebAssembly, typescript_type = "WebAssembly.LinkError")]
+        #[derive(Clone, Debug, PartialEq, Eq)]
+        pub type LinkError;
+
+        /// The `WebAssembly.LinkError()` constructor creates a new WebAssembly
+        /// LinkError object, which indicates an error during module
+        /// instantiation (besides traps from the start function).
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/LinkError)
+        #[wasm_bindgen(constructor, js_namespace = WebAssembly)]
+        pub fn new(message: &str) -> LinkError;
+    }
+
+    // WebAssembly.RuntimeError
+    #[wasm_bindgen]
+    extern "C" {
+        /// The `WebAssembly.RuntimeError()` constructor creates a new WebAssembly
+        /// `RuntimeError` object — the type that is thrown whenever WebAssembly
+        /// specifies a trap.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/RuntimeError)
+        #[wasm_bindgen(extends = Error, js_namespace = WebAssembly, typescript_type = "WebAssembly.RuntimeError")]
+        #[derive(Clone, Debug, PartialEq, Eq)]
+        pub type RuntimeError;
+
+        /// The `WebAssembly.RuntimeError()` constructor creates a new WebAssembly
+        /// `RuntimeError` object — the type that is thrown whenever WebAssembly
+        /// specifies a trap.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/RuntimeError)
+        #[wasm_bindgen(constructor, js_namespace = WebAssembly)]
+        pub fn new(message: &str) -> RuntimeError;
+    }
+
+    // WebAssembly.Module
+    #[wasm_bindgen]
+    extern "C" {
+        /// A `WebAssembly.Module` object contains stateless WebAssembly code
+        /// that has already been compiled by the browser and can be
+        /// efficiently shared with Workers, and instantiated multiple times.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module)
+        #[wasm_bindgen(js_namespace = WebAssembly, extends = Object, typescript_type = "WebAssembly.Module")]
+        #[derive(Clone, Debug, PartialEq, Eq)]
+        pub type Module;
+
+        /// A `WebAssembly.Module` object contains stateless WebAssembly code
+        /// that has already been compiled by the browser and can be
+        /// efficiently shared with Workers, and instantiated multiple times.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module)
+        #[wasm_bindgen(constructor, js_namespace = WebAssembly, catch)]
+        pub fn new(buffer_source: &JsValue) -> Result<Module, JsValue>;
+
+        /// The `WebAssembly.customSections()` function returns a copy of the
+        /// contents of all custom sections in the given module with the given
+        /// string name.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/customSections)
+        #[wasm_bindgen(static_method_of = Module, js_namespace = WebAssembly, js_name = customSections)]
+        pub fn custom_sections(module: &Module, sectionName: &str) -> Array;
+
+        /// The `WebAssembly.exports()` function returns an array containing
+        /// descriptions of all the declared exports of the given `Module`.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/exports)
+        #[wasm_bindgen(static_method_of = Module, js_namespace = WebAssembly)]
+        pub fn exports(module: &Module) -> Array;
+
+        /// The `WebAssembly.imports()` function returns an array containing
+        /// descriptions of all the declared imports of the given `Module`.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/imports)
+        #[wasm_bindgen(static_method_of = Module, js_namespace = WebAssembly)]
+        pub fn imports(module: &Module) -> Array;
+    }
+
+    // WebAssembly.Table
+    #[wasm_bindgen]
+    extern "C" {
+        /// The `WebAssembly.Table()` constructor creates a new `Table` object
+        /// of the given size and element type.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table)
+        #[wasm_bindgen(js_namespace = WebAssembly, extends = Object, typescript_type = "WebAssembly.Table")]
+        #[derive(Clone, Debug, PartialEq, Eq)]
+        pub type Table;
+
+        /// The `WebAssembly.Table()` constructor creates a new `Table` object
+        /// of the given size and element type.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table)
+        #[wasm_bindgen(constructor, js_namespace = WebAssembly, catch)]
+        pub fn new(table_descriptor: &Object) -> Result<Table, JsValue>;
+
+        /// The length prototype property of the `WebAssembly.Table` object
+        /// returns the length of the table, i.e. the number of elements in the
+        /// table.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/length)
+        #[wasm_bindgen(method, getter, js_namespace = WebAssembly)]
+        pub fn length(this: &Table) -> u32;
+
+        /// The `get()` prototype method of the `WebAssembly.Table()` object
+        /// retrieves a function reference stored at a given index.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/get)
+        #[wasm_bindgen(method, catch, js_namespace = WebAssembly)]
+        pub fn get(this: &Table, index: u32) -> Result<Function, JsValue>;
+
+        /// The `grow()` prototype method of the `WebAssembly.Table` object
+        /// increases the size of the `Table` instance by a specified number of
+        /// elements.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/grow)
+        #[wasm_bindgen(method, catch, js_namespace = WebAssembly)]
+        pub fn grow(this: &Table, additional_capacity: u32) -> Result<u32, JsValue>;
+
+        /// The `set()` prototype method of the `WebAssembly.Table` object mutates a
+        /// reference stored at a given index to a different value.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/set)
+        #[wasm_bindgen(method, catch, js_namespace = WebAssembly)]
+        pub fn set(this: &Table, index: u32, function: &Function) -> Result<(), JsValue>;
+    }
+
+    // WebAssembly.Global
+    #[wasm_bindgen]
+    extern "C" {
+        /// The `WebAssembly.Global()` constructor creates a new `Global` object
+        /// of the given type and value.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global)
+        #[wasm_bindgen(js_namespace = WebAssembly, extends = Object, typescript_type = "WebAssembly.Global")]
+        #[derive(Clone, Debug, PartialEq, Eq)]
+        pub type Global;
+
+        /// The `WebAssembly.Global()` constructor creates a new `Global` object
+        /// of the given type and value.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global)
+        #[wasm_bindgen(constructor, js_namespace = WebAssembly, catch)]
+        pub fn new(global_descriptor: &Object, value: &JsValue) -> Result<Global, JsValue>;
+
+        /// The value prototype property of the `WebAssembly.Global` object
+        /// returns the value of the global.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global)
+        #[wasm_bindgen(method, getter, structural, js_namespace = WebAssembly)]
+        pub fn value(this: &Global) -> JsValue;
+        #[wasm_bindgen(method, setter = value, structural, js_namespace = WebAssembly)]
+        pub fn set_value(this: &Global, value: &JsValue);
+    }
+
+    // WebAssembly.Memory
+    #[wasm_bindgen]
+    extern "C" {
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory)
+        #[wasm_bindgen(js_namespace = WebAssembly, extends = Object, typescript_type = "WebAssembly.Memory")]
+        #[derive(Clone, Debug, PartialEq, Eq)]
+        pub type Memory;
+
+        /// The `WebAssembly.Memory()` constructor creates a new `Memory` object
+        /// which is a resizable `ArrayBuffer` that holds the raw bytes of
+        /// memory accessed by a WebAssembly `Instance`.
+        ///
+        /// A memory created by JavaScript or in WebAssembly code will be
+        /// accessible and mutable from both JavaScript and WebAssembly.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory)
+        #[wasm_bindgen(constructor, js_namespace = WebAssembly, catch)]
+        pub fn new(descriptor: &Object) -> Result<Memory, JsValue>;
+
+        /// An accessor property that returns the buffer contained in the
+        /// memory.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/buffer)
+        #[wasm_bindgen(method, getter, js_namespace = WebAssembly)]
+        pub fn buffer(this: &Memory) -> JsValue;
+
+        /// The `grow()` protoype method of the `Memory` object increases the
+        /// size of the memory instance by a specified number of WebAssembly
+        /// pages.
+        ///
+        /// Takes the number of pages to grow (64KiB in size) and returns the
+        /// previous size of memory, in pages.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/grow)
+        #[wasm_bindgen(method, js_namespace = WebAssembly)]
+        pub fn grow(this: &Memory, pages: u32) -> u32;
+    }
+}
+
+/// The `JSON` object contains methods for parsing [JavaScript Object
+/// Notation (JSON)](https://json.org/) and converting values to JSON. It
+/// can't be called or constructed, and aside from its two method
+/// properties, it has no interesting functionality of its own.
+#[allow(non_snake_case)]
+pub mod JSON {
+    use super::*;
+
+    // JSON
+    #[wasm_bindgen]
+    extern "C" {
+        /// The `JSON.parse()` method parses a JSON string, constructing the
+        /// JavaScript value or object described by the string.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse)
+        #[wasm_bindgen(catch, js_namespace = JSON)]
+        pub fn parse(text: &str) -> Result<JsValue, JsValue>;
+
+        /// The `JSON.stringify()` method converts a JavaScript value to a JSON string.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify)
+        #[wasm_bindgen(catch, js_namespace = JSON)]
+        pub fn stringify(obj: &JsValue) -> Result<JsString, JsValue>;
+
+        /// The `JSON.stringify()` method converts a JavaScript value to a JSON string.
+        ///
+        /// The `replacer` argument is a function that alters the behavior of the stringification
+        /// process, or an array of String and Number objects that serve as a whitelist
+        /// for selecting/filtering the properties of the value object to be included
+        /// in the JSON string. If this value is null or not provided, all properties
+        /// of the object are included in the resulting JSON string.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify)
+        #[wasm_bindgen(catch, js_namespace = JSON, js_name = stringify)]
+        pub fn stringify_with_replacer(
+            obj: &JsValue,
+            replacer: &JsValue,
+        ) -> Result<JsString, JsValue>;
+
+        /// The `JSON.stringify()` method converts a JavaScript value to a JSON string.
+        ///
+        /// The `replacer` argument is a function that alters the behavior of the stringification
+        /// process, or an array of String and Number objects that serve as a whitelist
+        /// for selecting/filtering the properties of the value object to be included
+        /// in the JSON string. If this value is null or not provided, all properties
+        /// of the object are included in the resulting JSON string.
+        ///
+        /// The `space` argument is a String or Number object that's used to insert white space into
+        /// the output JSON string for readability purposes. If this is a Number, it
+        /// indicates the number of space characters to use as white space; this number
+        /// is capped at 10 (if it is greater, the value is just 10). Values less than
+        /// 1 indicate that no space should be used. If this is a String, the string
+        /// (or the first 10 characters of the string, if it's longer than that) is
+        /// used as white space. If this parameter is not provided (or is null), no
+        /// white space is used.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify)
+        #[wasm_bindgen(catch, js_namespace = JSON, js_name = stringify)]
+        pub fn stringify_with_replacer_and_space(
+            obj: &JsValue,
+            replacer: &JsValue,
+            space: &JsValue,
+        ) -> Result<JsString, JsValue>;
+
+    }
+}
+
+// JsString
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(js_name = String, extends = Object, is_type_of = JsValue::is_string, typescript_type = "string")]
+    #[derive(Clone, PartialEq, Eq)]
+    pub type JsString;
+
+    /// The length property of a String object indicates the length of a string,
+    /// in UTF-16 code units.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length)
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn length(this: &JsString) -> u32;
+
+    /// The 'at()' method returns a new string consisting of the single UTF-16
+    /// code unit located at the specified offset into the string, counting from
+    /// the end if it's negative.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/at)
+    #[wasm_bindgen(method, js_class = "String")]
+    pub fn at(this: &JsString, index: i32) -> Option<JsString>;
+
+    /// The String object's `charAt()` method returns a new string consisting of
+    /// the single UTF-16 code unit located at the specified offset into the
+    /// string.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charAt)
+    #[wasm_bindgen(method, js_class = "String", js_name = charAt)]
+    pub fn char_at(this: &JsString, index: u32) -> JsString;
+
+    /// The `charCodeAt()` method returns an integer between 0 and 65535
+    /// representing the UTF-16 code unit at the given index (the UTF-16 code
+    /// unit matches the Unicode code point for code points representable in a
+    /// single UTF-16 code unit, but might also be the first code unit of a
+    /// surrogate pair for code points not representable in a single UTF-16 code
+    /// unit, e.g. Unicode code points > 0x10000).  If you want the entire code
+    /// point value, use `codePointAt()`.
+    ///
+    /// Returns `NaN` if index is out of range.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charCodeAt)
+    #[wasm_bindgen(method, js_class = "String", js_name = charCodeAt)]
+    pub fn char_code_at(this: &JsString, index: u32) -> f64;
+
+    /// The `codePointAt()` method returns a non-negative integer that is the
+    /// Unicode code point value.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/codePointAt)
+    #[wasm_bindgen(method, js_class = "String", js_name = codePointAt)]
+    pub fn code_point_at(this: &JsString, pos: u32) -> JsValue;
+
+    /// The `concat()` method concatenates the string arguments to the calling
+    /// string and returns a new string.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat)
+    #[wasm_bindgen(method, js_class = "String")]
+    pub fn concat(this: &JsString, string_2: &JsValue) -> JsString;
+
+    /// The `endsWith()` method determines whether a string ends with the characters of a
+    /// specified string, returning true or false as appropriate.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith)
+    #[wasm_bindgen(method, js_class = "String", js_name = endsWith)]
+    pub fn ends_with(this: &JsString, search_string: &str, length: i32) -> bool;
+
+    /// The static `String.fromCharCode()` method returns a string created from
+    /// the specified sequence of UTF-16 code units.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode)
+    ///
+    /// # Notes
+    ///
+    /// There are a few bindings to `from_char_code` in `js-sys`: `from_char_code1`, `from_char_code2`, etc...
+    /// with different arities.
+    ///
+    /// Additionally, this function accepts `u16` for character codes, but
+    /// fixing others requires a breaking change release
+    /// (see https://github.com/rustwasm/wasm-bindgen/issues/1460 for details).
+    #[wasm_bindgen(static_method_of = JsString, js_class = "String", js_name = fromCharCode, variadic)]
+    pub fn from_char_code(char_codes: &[u16]) -> JsString;
+
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode)
+    #[wasm_bindgen(static_method_of = JsString, js_class = "String", js_name = fromCharCode)]
+    pub fn from_char_code1(a: u32) -> JsString;
+
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode)
+    #[wasm_bindgen(static_method_of = JsString, js_class = "String", js_name = fromCharCode)]
+    pub fn from_char_code2(a: u32, b: u32) -> JsString;
+
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode)
+    #[wasm_bindgen(static_method_of = JsString, js_class = "String", js_name = fromCharCode)]
+    pub fn from_char_code3(a: u32, b: u32, c: u32) -> JsString;
+
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode)
+    #[wasm_bindgen(static_method_of = JsString, js_class = "String", js_name = fromCharCode)]
+    pub fn from_char_code4(a: u32, b: u32, c: u32, d: u32) -> JsString;
+
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode)
+    #[wasm_bindgen(static_method_of = JsString, js_class = "String", js_name = fromCharCode)]
+    pub fn from_char_code5(a: u32, b: u32, c: u32, d: u32, e: u32) -> JsString;
+
+    /// The static `String.fromCodePoint()` method returns a string created by
+    /// using the specified sequence of code points.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint)
+    ///
+    /// # Exceptions
+    ///
+    /// A RangeError is thrown if an invalid Unicode code point is given
+    ///
+    /// # Notes
+    ///
+    /// There are a few bindings to `from_code_point` in `js-sys`: `from_code_point1`, `from_code_point2`, etc...
+    /// with different arities.
+    #[wasm_bindgen(catch, static_method_of = JsString, js_class = "String", js_name = fromCodePoint, variadic)]
+    pub fn from_code_point(code_points: &[u32]) -> Result<JsString, JsValue>;
+
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint)
+    #[wasm_bindgen(catch, static_method_of = JsString, js_class = "String", js_name = fromCodePoint)]
+    pub fn from_code_point1(a: u32) -> Result<JsString, JsValue>;
+
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint)
+    #[wasm_bindgen(catch, static_method_of = JsString, js_class = "String", js_name = fromCodePoint)]
+    pub fn from_code_point2(a: u32, b: u32) -> Result<JsString, JsValue>;
+
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint)
+    #[wasm_bindgen(catch, static_method_of = JsString, js_class = "String", js_name = fromCodePoint)]
+    pub fn from_code_point3(a: u32, b: u32, c: u32) -> Result<JsString, JsValue>;
+
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint)
+    #[wasm_bindgen(catch, static_method_of = JsString, js_class = "String", js_name = fromCodePoint)]
+    pub fn from_code_point4(a: u32, b: u32, c: u32, d: u32) -> Result<JsString, JsValue>;
+
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint)
+    #[wasm_bindgen(catch, static_method_of = JsString, js_class = "String", js_name = fromCodePoint)]
+    pub fn from_code_point5(a: u32, b: u32, c: u32, d: u32, e: u32) -> Result<JsString, JsValue>;
+
+    /// The `includes()` method determines whether one string may be found
+    /// within another string, returning true or false as appropriate.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes)
+    #[wasm_bindgen(method, js_class = "String")]
+    pub fn includes(this: &JsString, search_string: &str, position: i32) -> bool;
+
+    /// The `indexOf()` method returns the index within the calling String
+    /// object of the first occurrence of the specified value, starting the
+    /// search at fromIndex.  Returns -1 if the value is not found.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf)
+    #[wasm_bindgen(method, js_class = "String", js_name = indexOf)]
+    pub fn index_of(this: &JsString, search_value: &str, from_index: i32) -> i32;
+
+    /// The `lastIndexOf()` method returns the index within the calling String
+    /// object of the last occurrence of the specified value, searching
+    /// backwards from fromIndex.  Returns -1 if the value is not found.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf)
+    #[wasm_bindgen(method, js_class = "String", js_name = lastIndexOf)]
+    pub fn last_index_of(this: &JsString, search_value: &str, from_index: i32) -> i32;
+
+    /// The `localeCompare()` method returns a number indicating whether
+    /// a reference string comes before or after or is the same as
+    /// the given string in sort order.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare)
+    #[wasm_bindgen(method, js_class = "String", js_name = localeCompare)]
+    pub fn locale_compare(
+        this: &JsString,
+        compare_string: &str,
+        locales: &Array,
+        options: &Object,
+    ) -> i32;
+
+    /// The `match()` method retrieves the matches when matching a string against a regular expression.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)
+    #[wasm_bindgen(method, js_class = "String", js_name = match)]
+    pub fn match_(this: &JsString, pattern: &RegExp) -> Option<Object>;
+
+    /// The `match_all()` method is similar to `match()`, but gives an iterator of `exec()` arrays, which preserve capture groups.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/matchAll)
+    #[wasm_bindgen(method, js_class = "String", js_name = matchAll)]
+    pub fn match_all(this: &JsString, pattern: &RegExp) -> Iterator;
+
+    /// The `normalize()` method returns the Unicode Normalization Form
+    /// of a given string (if the value isn't a string, it will be converted to one first).
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize)
+    #[wasm_bindgen(method, js_class = "String")]
+    pub fn normalize(this: &JsString, form: &str) -> JsString;
+
+    /// The `padEnd()` method pads the current string with a given string
+    /// (repeated, if needed) so that the resulting string reaches a given
+    /// length. The padding is applied from the end (right) of the current
+    /// string.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padEnd)
+    #[wasm_bindgen(method, js_class = "String", js_name = padEnd)]
+    pub fn pad_end(this: &JsString, target_length: u32, pad_string: &str) -> JsString;
+
+    /// The `padStart()` method pads the current string with another string
+    /// (repeated, if needed) so that the resulting string reaches the given
+    /// length. The padding is applied from the start (left) of the current
+    /// string.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart)
+    #[wasm_bindgen(method, js_class = "String", js_name = padStart)]
+    pub fn pad_start(this: &JsString, target_length: u32, pad_string: &str) -> JsString;
+
+    /// The `repeat()` method constructs and returns a new string which contains the specified
+    /// number of copies of the string on which it was called, concatenated together.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat)
+    #[wasm_bindgen(method, js_class = "String")]
+    pub fn repeat(this: &JsString, count: i32) -> JsString;
+
+    /// The `replace()` method returns a new string with some or all matches of a pattern
+    /// replaced by a replacement. The pattern can be a string or a RegExp, and
+    /// the replacement can be a string or a function to be called for each match.
+    ///
+    /// Note: The original string will remain unchanged.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace)
+    #[wasm_bindgen(method, js_class = "String")]
+    pub fn replace(this: &JsString, pattern: &str, replacement: &str) -> JsString;
+
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace)
+    #[wasm_bindgen(method, js_class = "String", js_name = replace)]
+    pub fn replace_with_function(
+        this: &JsString,
+        pattern: &str,
+        replacement: &Function,
+    ) -> JsString;
+
+    #[wasm_bindgen(method, js_class = "String", js_name = replace)]
+    pub fn replace_by_pattern(this: &JsString, pattern: &RegExp, replacement: &str) -> JsString;
+
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace)
+    #[wasm_bindgen(method, js_class = "String", js_name = replace)]
+    pub fn replace_by_pattern_with_function(
+        this: &JsString,
+        pattern: &RegExp,
+        replacement: &Function,
+    ) -> JsString;
+
+    /// The `replace_all()` method returns a new string with all matches of a pattern
+    /// replaced by a replacement. The pattern can be a string or a global RegExp, and
+    /// the replacement can be a string or a function to be called for each match.
+    ///
+    /// Note: The original string will remain unchanged.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll)
+    #[wasm_bindgen(method, js_class = "String", js_name = replaceAll)]
+    pub fn replace_all(this: &JsString, pattern: &str, replacement: &str) -> JsString;
+
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll)
+    #[wasm_bindgen(method, js_class = "String", js_name = replaceAll)]
+    pub fn replace_all_with_function(
+        this: &JsString,
+        pattern: &str,
+        replacement: &Function,
+    ) -> JsString;
+
+    #[wasm_bindgen(method, js_class = "String", js_name = replaceAll)]
+    pub fn replace_all_by_pattern(this: &JsString, pattern: &RegExp, replacement: &str)
+        -> JsString;
+
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll)
+    #[wasm_bindgen(method, js_class = "String", js_name = replaceAll)]
+    pub fn replace_all_by_pattern_with_function(
+        this: &JsString,
+        pattern: &RegExp,
+        replacement: &Function,
+    ) -> JsString;
+
+    /// The `search()` method executes a search for a match between
+    /// a regular expression and this String object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/search)
+    #[wasm_bindgen(method, js_class = "String")]
+    pub fn search(this: &JsString, pattern: &RegExp) -> i32;
+
+    /// The `slice()` method extracts a section of a string and returns it as a
+    /// new string, without modifying the original string.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice)
+    #[wasm_bindgen(method, js_class = "String")]
+    pub fn slice(this: &JsString, start: u32, end: u32) -> JsString;
+
+    /// The `split()` method splits a String object into an array of strings by separating the string
+    /// into substrings, using a specified separator string to determine where to make each split.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)
+    #[wasm_bindgen(method, js_class = "String")]
+    pub fn split(this: &JsString, separator: &str) -> Array;
+
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)
+    #[wasm_bindgen(method, js_class = "String", js_name = split)]
+    pub fn split_limit(this: &JsString, separator: &str, limit: u32) -> Array;
+
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)
+    #[wasm_bindgen(method, js_class = "String", js_name = split)]
+    pub fn split_by_pattern(this: &JsString, pattern: &RegExp) -> Array;
+
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)
+    #[wasm_bindgen(method, js_class = "String", js_name = split)]
+    pub fn split_by_pattern_limit(this: &JsString, pattern: &RegExp, limit: u32) -> Array;
+
+    /// The `startsWith()` method determines whether a string begins with the
+    /// characters of a specified string, returning true or false as
+    /// appropriate.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith)
+    #[wasm_bindgen(method, js_class = "String", js_name = startsWith)]
+    pub fn starts_with(this: &JsString, search_string: &str, position: u32) -> bool;
+
+    /// The `substring()` method returns the part of the string between the
+    /// start and end indexes, or to the end of the string.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring)
+    #[wasm_bindgen(method, js_class = "String")]
+    pub fn substring(this: &JsString, index_start: u32, index_end: u32) -> JsString;
+
+    /// The `substr()` method returns the part of a string between
+    /// the start index and a number of characters after it.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr)
+    #[wasm_bindgen(method, js_class = "String")]
+    pub fn substr(this: &JsString, start: i32, length: i32) -> JsString;
+
+    /// The `toLocaleLowerCase()` method returns the calling string value converted to lower case,
+    /// according to any locale-specific case mappings.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase)
+    #[wasm_bindgen(method, js_class = "String", js_name = toLocaleLowerCase)]
+    pub fn to_locale_lower_case(this: &JsString, locale: Option<&str>) -> JsString;
+
+    /// The `toLocaleUpperCase()` method returns the calling string value converted to upper case,
+    /// according to any locale-specific case mappings.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)
+    #[wasm_bindgen(method, js_class = "String", js_name = toLocaleUpperCase)]
+    pub fn to_locale_upper_case(this: &JsString, locale: Option<&str>) -> JsString;
+
+    /// The `toLowerCase()` method returns the calling string value
+    /// converted to lower case.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)
+    #[wasm_bindgen(method, js_class = "String", js_name = toLowerCase)]
+    pub fn to_lower_case(this: &JsString) -> JsString;
+
+    /// The `toString()` method returns a string representing the specified
+    /// object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toString)
+    #[wasm_bindgen(method, js_class = "String", js_name = toString)]
+    pub fn to_string(this: &JsString) -> JsString;
+
+    /// The `toUpperCase()` method returns the calling string value converted to
+    /// uppercase (the value will be converted to a string if it isn't one).
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)
+    #[wasm_bindgen(method, js_class = "String", js_name = toUpperCase)]
+    pub fn to_upper_case(this: &JsString) -> JsString;
+
+    /// The `trim()` method removes whitespace from both ends of a string.
+    /// Whitespace in this context is all the whitespace characters (space, tab,
+    /// no-break space, etc.) and all the line terminator characters (LF, CR,
+    /// etc.).
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trim)
+    #[wasm_bindgen(method, js_class = "String")]
+    pub fn trim(this: &JsString) -> JsString;
+
+    /// The `trimEnd()` method removes whitespace from the end of a string.
+    /// `trimRight()` is an alias of this method.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trimEnd)
+    #[wasm_bindgen(method, js_class = "String", js_name = trimEnd)]
+    pub fn trim_end(this: &JsString) -> JsString;
+
+    /// The `trimEnd()` method removes whitespace from the end of a string.
+    /// `trimRight()` is an alias of this method.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trimEnd)
+    #[wasm_bindgen(method, js_class = "String", js_name = trimRight)]
+    pub fn trim_right(this: &JsString) -> JsString;
+
+    /// The `trimStart()` method removes whitespace from the beginning of a
+    /// string. `trimLeft()` is an alias of this method.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trimStart)
+    #[wasm_bindgen(method, js_class = "String", js_name = trimStart)]
+    pub fn trim_start(this: &JsString) -> JsString;
+
+    /// The `trimStart()` method removes whitespace from the beginning of a
+    /// string. `trimLeft()` is an alias of this method.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trimStart)
+    #[wasm_bindgen(method, js_class = "String", js_name = trimLeft)]
+    pub fn trim_left(this: &JsString) -> JsString;
+
+    /// The `valueOf()` method returns the primitive value of a `String` object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/valueOf)
+    #[wasm_bindgen(method, js_class = "String", js_name = valueOf)]
+    pub fn value_of(this: &JsString) -> JsString;
+
+    /// The static `raw()` method is a tag function of template literals,
+    /// similar to the `r` prefix in Python or the `@` prefix in C# for string literals.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/raw)
+    #[wasm_bindgen(catch, variadic, static_method_of = JsString, js_class = "String")]
+    pub fn raw(call_site: &Object, substitutions: &Array) -> Result<JsString, JsValue>;
+
+    /// The static `raw()` method is a tag function of template literals,
+    /// similar to the `r` prefix in Python or the `@` prefix in C# for string literals.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/raw)
+    #[wasm_bindgen(catch, static_method_of = JsString, js_class = "String", js_name = raw)]
+    pub fn raw_0(call_site: &Object) -> Result<JsString, JsValue>;
+
+    /// The static `raw()` method is a tag function of template literals,
+    /// similar to the `r` prefix in Python or the `@` prefix in C# for string literals.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/raw)
+    #[wasm_bindgen(catch, static_method_of = JsString, js_class = "String", js_name = raw)]
+    pub fn raw_1(call_site: &Object, substitutions_1: &str) -> Result<JsString, JsValue>;
+
+    /// The static `raw()` method is a tag function of template literals,
+    /// similar to the `r` prefix in Python or the `@` prefix in C# for string literals.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/raw)
+    #[wasm_bindgen(catch, static_method_of = JsString, js_class = "String", js_name = raw)]
+    pub fn raw_2(
+        call_site: &Object,
+        substitutions_1: &str,
+        substitutions_2: &str,
+    ) -> Result<JsString, JsValue>;
+
+    /// The static `raw()` method is a tag function of template literals,
+    /// similar to the `r` prefix in Python or the `@` prefix in C# for string literals.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/raw)
+    #[wasm_bindgen(catch, static_method_of = JsString, js_class = "String", js_name = raw)]
+    pub fn raw_3(
+        call_site: &Object,
+        substitutions_1: &str,
+        substitutions_2: &str,
+        substitutions_3: &str,
+    ) -> Result<JsString, JsValue>;
+
+    /// The static `raw()` method is a tag function of template literals,
+    /// similar to the `r` prefix in Python or the `@` prefix in C# for string literals.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/raw)
+    #[wasm_bindgen(catch, static_method_of = JsString, js_class = "String", js_name = raw)]
+    pub fn raw_4(
+        call_site: &Object,
+        substitutions_1: &str,
+        substitutions_2: &str,
+        substitutions_3: &str,
+        substitutions_4: &str,
+    ) -> Result<JsString, JsValue>;
+
+    /// The static `raw()` method is a tag function of template literals,
+    /// similar to the `r` prefix in Python or the `@` prefix in C# for string literals.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/raw)
+    #[wasm_bindgen(catch, static_method_of = JsString, js_class = "String", js_name = raw)]
+    pub fn raw_5(
+        call_site: &Object,
+        substitutions_1: &str,
+        substitutions_2: &str,
+        substitutions_3: &str,
+        substitutions_4: &str,
+        substitutions_5: &str,
+    ) -> Result<JsString, JsValue>;
+
+    /// The static `raw()` method is a tag function of template literals,
+    /// similar to the `r` prefix in Python or the `@` prefix in C# for string literals.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/raw)
+    #[wasm_bindgen(catch, static_method_of = JsString, js_class = "String", js_name = raw)]
+    pub fn raw_6(
+        call_site: &Object,
+        substitutions_1: &str,
+        substitutions_2: &str,
+        substitutions_3: &str,
+        substitutions_4: &str,
+        substitutions_5: &str,
+        substitutions_6: &str,
+    ) -> Result<JsString, JsValue>;
+
+    /// The static `raw()` method is a tag function of template literals,
+    /// similar to the `r` prefix in Python or the `@` prefix in C# for string literals.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/raw)
+    #[wasm_bindgen(catch, static_method_of = JsString, js_class = "String", js_name = raw)]
+    pub fn raw_7(
+        call_site: &Object,
+        substitutions_1: &str,
+        substitutions_2: &str,
+        substitutions_3: &str,
+        substitutions_4: &str,
+        substitutions_5: &str,
+        substitutions_6: &str,
+        substitutions_7: &str,
+    ) -> Result<JsString, JsValue>;
+}
+
+impl JsString {
+    /// Returns the `JsString` value of this JS value if it's an instance of a
+    /// string.
+    ///
+    /// If this JS value is not an instance of a string then this returns
+    /// `None`.
+    #[deprecated(note = "recommended to use dyn_ref instead which is now equivalent")]
+    pub fn try_from(val: &JsValue) -> Option<&JsString> {
+        val.dyn_ref()
+    }
+
+    /// Returns whether this string is a valid UTF-16 string.
+    ///
+    /// This is useful for learning whether `String::from(..)` will return a
+    /// lossless representation of the JS string. If this string contains
+    /// unpaired surrogates then `String::from` will succeed but it will be a
+    /// lossy representation of the JS string because unpaired surrogates will
+    /// become replacement characters.
+    ///
+    /// If this function returns `false` then to get a lossless representation
+    /// of the string you'll need to manually use the `iter` method (or the
+    /// `char_code_at` accessor) to view the raw character codes.
+    ///
+    /// For more information, see the documentation on [JS strings vs Rust
+    /// strings][docs]
+    ///
+    /// [docs]: https://rustwasm.github.io/docs/wasm-bindgen/reference/types/str.html
+    pub fn is_valid_utf16(&self) -> bool {
+        std::char::decode_utf16(self.iter()).all(|i| i.is_ok())
+    }
+
+    /// Returns an iterator over the `u16` character codes that make up this JS
+    /// string.
+    ///
+    /// This method will call `char_code_at` for each code in this JS string,
+    /// returning an iterator of the codes in sequence.
+    pub fn iter<'a>(
+        &'a self,
+    ) -> impl ExactSizeIterator<Item = u16> + DoubleEndedIterator<Item = u16> + 'a {
+        (0..self.length()).map(move |i| self.char_code_at(i) as u16)
+    }
+
+    /// If this string consists of a single Unicode code point, then this method
+    /// converts it into a Rust `char` without doing any allocations.
+    ///
+    /// If this JS value is not a valid UTF-8 or consists of more than a single
+    /// codepoint, then this returns `None`.
+    ///
+    /// Note that a single Unicode code point might be represented as more than
+    /// one code unit on the JavaScript side. For example, a JavaScript string
+    /// `"\uD801\uDC37"` is actually a single Unicode code point U+10437 which
+    /// corresponds to a character '𐐷'.
+    pub fn as_char(&self) -> Option<char> {
+        let len = self.length();
+
+        if len == 0 || len > 2 {
+            return None;
+        }
+
+        // This will be simplified when definitions are fixed:
+        // https://github.com/rustwasm/wasm-bindgen/issues/1362
+        let cp = self.code_point_at(0).as_f64().unwrap_throw() as u32;
+
+        let c = std::char::from_u32(cp)?;
+
+        if c.len_utf16() as u32 == len {
+            Some(c)
+        } else {
+            None
+        }
+    }
+}
+
+impl PartialEq<str> for JsString {
+    fn eq(&self, other: &str) -> bool {
+        String::from(self) == other
+    }
+}
+
+impl<'a> PartialEq<&'a str> for JsString {
+    fn eq(&self, other: &&'a str) -> bool {
+        <JsString as PartialEq<str>>::eq(self, other)
+    }
+}
+
+impl PartialEq<String> for JsString {
+    fn eq(&self, other: &String) -> bool {
+        <JsString as PartialEq<str>>::eq(self, other)
+    }
+}
+
+impl<'a> PartialEq<&'a String> for JsString {
+    fn eq(&self, other: &&'a String) -> bool {
+        <JsString as PartialEq<str>>::eq(self, other)
+    }
+}
+
+impl<'a> From<&'a str> for JsString {
+    fn from(s: &'a str) -> Self {
+        JsString::unchecked_from_js(JsValue::from_str(s))
+    }
+}
+
+impl From<String> for JsString {
+    fn from(s: String) -> Self {
+        From::from(&*s)
+    }
+}
+
+impl From<char> for JsString {
+    #[inline]
+    fn from(c: char) -> Self {
+        JsString::from_code_point1(c as u32).unwrap_throw()
+    }
+}
+
+impl<'a> From<&'a JsString> for String {
+    fn from(s: &'a JsString) -> Self {
+        s.obj.as_string().unwrap_throw()
+    }
+}
+
+impl From<JsString> for String {
+    fn from(s: JsString) -> Self {
+        From::from(&s)
+    }
+}
+
+impl fmt::Debug for JsString {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(&String::from(self), f)
+    }
+}
+
+impl fmt::Display for JsString {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(&String::from(self), f)
+    }
+}
+
+impl str::FromStr for JsString {
+    type Err = convert::Infallible;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(JsString::from(s))
+    }
+}
+
+// Symbol
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(is_type_of = JsValue::is_symbol, typescript_type = "Symbol")]
+    #[derive(Clone, Debug)]
+    pub type Symbol;
+
+    /// The `Symbol.hasInstance` well-known symbol is used to determine
+    /// if a constructor object recognizes an object as its instance.
+    /// The `instanceof` operator's behavior can be customized by this symbol.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/hasInstance)
+    #[wasm_bindgen(static_method_of = Symbol, getter, structural, js_name = hasInstance)]
+    pub fn has_instance() -> Symbol;
+
+    /// The `Symbol.isConcatSpreadable` well-known symbol is used to configure
+    /// if an object should be flattened to its array elements when using the
+    /// `Array.prototype.concat()` method.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/isConcatSpreadable)
+    #[wasm_bindgen(static_method_of = Symbol, getter, structural, js_name = isConcatSpreadable)]
+    pub fn is_concat_spreadable() -> Symbol;
+
+    /// The `Symbol.asyncIterator` well-known symbol specifies the default AsyncIterator for an object.
+    /// If this property is set on an object, it is an async iterable and can be used in a `for await...of` loop.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/asyncIterator)
+    #[wasm_bindgen(static_method_of = Symbol, getter, structural, js_name = asyncIterator)]
+    pub fn async_iterator() -> Symbol;
+
+    /// The `Symbol.iterator` well-known symbol specifies the default iterator
+    /// for an object.  Used by `for...of`.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/iterator)
+    #[wasm_bindgen(static_method_of = Symbol, getter, structural)]
+    pub fn iterator() -> Symbol;
+
+    /// The `Symbol.match` well-known symbol specifies the matching of a regular
+    /// expression against a string. This function is called by the
+    /// `String.prototype.match()` method.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/match)
+    #[wasm_bindgen(static_method_of = Symbol, getter, structural, js_name = match)]
+    pub fn match_() -> Symbol;
+
+    /// The `Symbol.replace` well-known symbol specifies the method that
+    /// replaces matched substrings of a string.  This function is called by the
+    /// `String.prototype.replace()` method.
+    ///
+    /// For more information, see `RegExp.prototype[@@replace]()` and
+    /// `String.prototype.replace()`.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/replace)
+    #[wasm_bindgen(static_method_of = Symbol, getter, structural)]
+    pub fn replace() -> Symbol;
+
+    /// The `Symbol.search` well-known symbol specifies the method that returns
+    /// the index within a string that matches the regular expression.  This
+    /// function is called by the `String.prototype.search()` method.
+    ///
+    /// For more information, see `RegExp.prototype[@@search]()` and
+    /// `String.prototype.search()`.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/search)
+    #[wasm_bindgen(static_method_of = Symbol, getter, structural)]
+    pub fn search() -> Symbol;
+
+    /// The well-known symbol `Symbol.species` specifies a function-valued
+    /// property that the constructor function uses to create derived objects.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/species)
+    #[wasm_bindgen(static_method_of = Symbol, getter, structural)]
+    pub fn species() -> Symbol;
+
+    /// The `Symbol.split` well-known symbol specifies the method that splits a
+    /// string at the indices that match a regular expression.  This function is
+    /// called by the `String.prototype.split()` method.
+    ///
+    /// For more information, see `RegExp.prototype[@@split]()` and
+    /// `String.prototype.split()`.
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/split)
+    #[wasm_bindgen(static_method_of = Symbol, getter, structural)]
+    pub fn split() -> Symbol;
+
+    /// The `Symbol.toPrimitive` is a symbol that specifies a function valued
+    /// property that is called to convert an object to a corresponding
+    /// primitive value.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toPrimitive)
+    #[wasm_bindgen(static_method_of = Symbol, getter, structural, js_name = toPrimitive)]
+    pub fn to_primitive() -> Symbol;
+
+    /// The `Symbol.toStringTag` well-known symbol is a string valued property
+    /// that is used in the creation of the default string description of an
+    /// object.  It is accessed internally by the `Object.prototype.toString()`
+    /// method.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toString)
+    #[wasm_bindgen(static_method_of = Symbol, getter, structural, js_name = toStringTag)]
+    pub fn to_string_tag() -> Symbol;
+
+    /// The `Symbol.for(key)` method searches for existing symbols in a runtime-wide symbol registry with
+    /// the given key and returns it if found.
+    /// Otherwise a new symbol gets created in the global symbol registry with this key.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/for)
+    #[wasm_bindgen(static_method_of = Symbol, js_name = for)]
+    pub fn for_(key: &str) -> Symbol;
+
+    /// The `Symbol.keyFor(sym)` method retrieves a shared symbol key from the global symbol registry for the given symbol.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/keyFor)
+    #[wasm_bindgen(static_method_of = Symbol, js_name = keyFor)]
+    pub fn key_for(sym: &Symbol) -> JsValue;
+
+    /// The `toString()` method returns a string representing the specified Symbol object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toString)
+    #[wasm_bindgen(method, js_name = toString)]
+    pub fn to_string(this: &Symbol) -> JsString;
+
+    /// The `Symbol.unscopables` well-known symbol is used to specify an object
+    /// value of whose own and inherited property names are excluded from the
+    /// with environment bindings of the associated object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/unscopables)
+    #[wasm_bindgen(static_method_of = Symbol, getter, structural)]
+    pub fn unscopables() -> Symbol;
+
+    /// The `valueOf()` method returns the primitive value of a Symbol object.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/valueOf)
+    #[wasm_bindgen(method, js_name = valueOf)]
+    pub fn value_of(this: &Symbol) -> Symbol;
+}
+
+#[allow(non_snake_case)]
+pub mod Intl {
+    use super::*;
+
+    // Intl
+    #[wasm_bindgen]
+    extern "C" {
+        /// The `Intl.getCanonicalLocales()` method returns an array containing
+        /// the canonical locale names. Duplicates will be omitted and elements
+        /// will be validated as structurally valid language tags.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/getCanonicalLocales)
+        #[wasm_bindgen(js_name = getCanonicalLocales, js_namespace = Intl)]
+        pub fn get_canonical_locales(s: &JsValue) -> Array;
+    }
+
+    // Intl.Collator
+    #[wasm_bindgen]
+    extern "C" {
+        /// The `Intl.Collator` object is a constructor for collators, objects
+        /// that enable language sensitive string comparison.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Collator)
+        #[wasm_bindgen(extends = Object, js_namespace = Intl, typescript_type = "Intl.Collator")]
+        #[derive(Clone, Debug)]
+        pub type Collator;
+
+        /// The `Intl.Collator` object is a constructor for collators, objects
+        /// that enable language sensitive string comparison.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Collator)
+        #[wasm_bindgen(constructor, js_namespace = Intl)]
+        pub fn new(locales: &Array, options: &Object) -> Collator;
+
+        /// The Intl.Collator.prototype.compare property returns a function that
+        /// compares two strings according to the sort order of this Collator
+        /// object.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Collator/compare)
+        #[wasm_bindgen(method, getter, js_class = "Intl.Collator")]
+        pub fn compare(this: &Collator) -> Function;
+
+        /// The `Intl.Collator.prototype.resolvedOptions()` method returns a new
+        /// object with properties reflecting the locale and collation options
+        /// computed during initialization of this Collator object.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Collator/resolvedOptions)
+        #[wasm_bindgen(method, js_namespace = Intl, js_name = resolvedOptions)]
+        pub fn resolved_options(this: &Collator) -> Object;
+
+        /// The `Intl.Collator.supportedLocalesOf()` method returns an array
+        /// containing those of the provided locales that are supported in
+        /// collation without having to fall back to the runtime's default
+        /// locale.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Collator/supportedLocalesOf)
+        #[wasm_bindgen(static_method_of = Collator, js_namespace = Intl, js_name = supportedLocalesOf)]
+        pub fn supported_locales_of(locales: &Array, options: &Object) -> Array;
+    }
+
+    impl Default for Collator {
+        fn default() -> Self {
+            Self::new(
+                &JsValue::UNDEFINED.unchecked_into(),
+                &JsValue::UNDEFINED.unchecked_into(),
+            )
+        }
+    }
+
+    // Intl.DateTimeFormat
+    #[wasm_bindgen]
+    extern "C" {
+        /// The `Intl.DateTimeFormat` object is a constructor for objects
+        /// that enable language-sensitive date and time formatting.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat)
+        #[wasm_bindgen(extends = Object, js_namespace = Intl, typescript_type = "Intl.DateTimeFormat")]
+        #[derive(Clone, Debug)]
+        pub type DateTimeFormat;
+
+        /// The `Intl.DateTimeFormat` object is a constructor for objects
+        /// that enable language-sensitive date and time formatting.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat)
+        #[wasm_bindgen(constructor, js_namespace = Intl)]
+        pub fn new(locales: &Array, options: &Object) -> DateTimeFormat;
+
+        /// The Intl.DateTimeFormat.prototype.format property returns a getter function that
+        /// formats a date according to the locale and formatting options of this
+        /// Intl.DateTimeFormat object.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/format)
+        #[wasm_bindgen(method, getter, js_class = "Intl.DateTimeFormat")]
+        pub fn format(this: &DateTimeFormat) -> Function;
+
+        /// The `Intl.DateTimeFormat.prototype.formatToParts()` method allows locale-aware
+        /// formatting of strings produced by DateTimeFormat formatters.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/formatToParts)
+        #[wasm_bindgen(method, js_class = "Intl.DateTimeFormat", js_name = formatToParts)]
+        pub fn format_to_parts(this: &DateTimeFormat, date: &Date) -> Array;
+
+        /// The `Intl.DateTimeFormat.prototype.resolvedOptions()` method returns a new
+        /// object with properties reflecting the locale and date and time formatting
+        /// options computed during initialization of this DateTimeFormat object.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/resolvedOptions)
+        #[wasm_bindgen(method, js_namespace = Intl, js_name = resolvedOptions)]
+        pub fn resolved_options(this: &DateTimeFormat) -> Object;
+
+        /// The `Intl.DateTimeFormat.supportedLocalesOf()` method returns an array
+        /// containing those of the provided locales that are supported in date
+        /// and time formatting without having to fall back to the runtime's default
+        /// locale.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/supportedLocalesOf)
+        #[wasm_bindgen(static_method_of = DateTimeFormat, js_namespace = Intl, js_name = supportedLocalesOf)]
+        pub fn supported_locales_of(locales: &Array, options: &Object) -> Array;
+    }
+
+    impl Default for DateTimeFormat {
+        fn default() -> Self {
+            Self::new(
+                &JsValue::UNDEFINED.unchecked_into(),
+                &JsValue::UNDEFINED.unchecked_into(),
+            )
+        }
+    }
+
+    // Intl.NumberFormat
+    #[wasm_bindgen]
+    extern "C" {
+        /// The `Intl.NumberFormat` object is a constructor for objects
+        /// that enable language sensitive number formatting.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat)
+        #[wasm_bindgen(extends = Object, js_namespace = Intl, typescript_type = "Intl.NumberFormat")]
+        #[derive(Clone, Debug)]
+        pub type NumberFormat;
+
+        /// The `Intl.NumberFormat` object is a constructor for objects
+        /// that enable language sensitive number formatting.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat)
+        #[wasm_bindgen(constructor, js_namespace = Intl)]
+        pub fn new(locales: &Array, options: &Object) -> NumberFormat;
+
+        /// The Intl.NumberFormat.prototype.format property returns a getter function that
+        /// formats a number according to the locale and formatting options of this
+        /// NumberFormat object.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/format)
+        #[wasm_bindgen(method, getter, js_class = "Intl.NumberFormat")]
+        pub fn format(this: &NumberFormat) -> Function;
+
+        /// The `Intl.Numberformat.prototype.formatToParts()` method allows locale-aware
+        /// formatting of strings produced by NumberTimeFormat formatters.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/formatToParts)
+        #[wasm_bindgen(method, js_class = "Intl.NumberFormat", js_name = formatToParts)]
+        pub fn format_to_parts(this: &NumberFormat, number: f64) -> Array;
+
+        /// The `Intl.NumberFormat.prototype.resolvedOptions()` method returns a new
+        /// object with properties reflecting the locale and number formatting
+        /// options computed during initialization of this NumberFormat object.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/resolvedOptions)
+        #[wasm_bindgen(method, js_namespace = Intl, js_name = resolvedOptions)]
+        pub fn resolved_options(this: &NumberFormat) -> Object;
+
+        /// The `Intl.NumberFormat.supportedLocalesOf()` method returns an array
+        /// containing those of the provided locales that are supported in number
+        /// formatting without having to fall back to the runtime's default locale.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/supportedLocalesOf)
+        #[wasm_bindgen(static_method_of = NumberFormat, js_namespace = Intl, js_name = supportedLocalesOf)]
+        pub fn supported_locales_of(locales: &Array, options: &Object) -> Array;
+    }
+
+    impl Default for NumberFormat {
+        fn default() -> Self {
+            Self::new(
+                &JsValue::UNDEFINED.unchecked_into(),
+                &JsValue::UNDEFINED.unchecked_into(),
+            )
+        }
+    }
+
+    // Intl.PluralRules
+    #[wasm_bindgen]
+    extern "C" {
+        /// The `Intl.PluralRules` object is a constructor for objects
+        /// that enable plural sensitive formatting and plural language rules.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/PluralRules)
+        #[wasm_bindgen(extends = Object, js_namespace = Intl, typescript_type = "Intl.PluralRules")]
+        #[derive(Clone, Debug)]
+        pub type PluralRules;
+
+        /// The `Intl.PluralRules` object is a constructor for objects
+        /// that enable plural sensitive formatting and plural language rules.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/PluralRules)
+        #[wasm_bindgen(constructor, js_namespace = Intl)]
+        pub fn new(locales: &Array, options: &Object) -> PluralRules;
+
+        /// The `Intl.PluralRules.prototype.resolvedOptions()` method returns a new
+        /// object with properties reflecting the locale and plural formatting
+        /// options computed during initialization of this PluralRules object.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/PluralRules/resolvedOptions)
+        #[wasm_bindgen(method, js_namespace = Intl, js_name = resolvedOptions)]
+        pub fn resolved_options(this: &PluralRules) -> Object;
+
+        /// The `Intl.PluralRules.prototype.select()` method returns a String indicating
+        /// which plural rule to use for locale-aware formatting.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/PluralRules/select)
+        #[wasm_bindgen(method, js_namespace = Intl)]
+        pub fn select(this: &PluralRules, number: f64) -> JsString;
+
+        /// The `Intl.PluralRules.supportedLocalesOf()` method returns an array
+        /// containing those of the provided locales that are supported in plural
+        /// formatting without having to fall back to the runtime's default locale.
+        ///
+        /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/PluralRules/supportedLocalesOf)
+        #[wasm_bindgen(static_method_of = PluralRules, js_namespace = Intl, js_name = supportedLocalesOf)]
+        pub fn supported_locales_of(locales: &Array, options: &Object) -> Array;
+    }
+
+    impl Default for PluralRules {
+        fn default() -> Self {
+            Self::new(
+                &JsValue::UNDEFINED.unchecked_into(),
+                &JsValue::UNDEFINED.unchecked_into(),
+            )
+        }
+    }
+}
+
+// Promise
+#[wasm_bindgen]
+extern "C" {
+    /// The `Promise` object represents the eventual completion (or failure) of
+    /// an asynchronous operation, and its resulting value.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
+    #[must_use]
+    #[wasm_bindgen(extends = Object, typescript_type = "Promise<any>")]
+    #[derive(Clone, Debug)]
+    pub type Promise;
+
+    /// Creates a new `Promise` with the provided executor `cb`
+    ///
+    /// The `cb` is a function that is passed with the arguments `resolve` and
+    /// `reject`. The `cb` function is executed immediately by the `Promise`
+    /// implementation, passing `resolve` and `reject` functions (the executor
+    /// is called before the `Promise` constructor even returns the created
+    /// object). The `resolve` and `reject` functions, when called, resolve or
+    /// reject the promise, respectively. The executor normally initiates
+    /// some asynchronous work, and then, once that completes, either calls
+    /// the `resolve` function to resolve the promise or else rejects it if an
+    /// error occurred.
+    ///
+    /// If an error is thrown in the executor function, the promise is rejected.
+    /// The return value of the executor is ignored.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
+    #[wasm_bindgen(constructor)]
+    pub fn new(cb: &mut dyn FnMut(Function, Function)) -> Promise;
+
+    /// The `Promise.all(iterable)` method returns a single `Promise` that
+    /// resolves when all of the promises in the iterable argument have resolved
+    /// or when the iterable argument contains no promises. It rejects with the
+    /// reason of the first promise that rejects.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all)
+    #[wasm_bindgen(static_method_of = Promise)]
+    pub fn all(obj: &JsValue) -> Promise;
+
+    /// The `Promise.allSettled(iterable)` method returns a single `Promise` that
+    /// resolves when all of the promises in the iterable argument have either
+    /// fulfilled or rejected or when the iterable argument contains no promises.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled)
+    #[wasm_bindgen(static_method_of = Promise, js_name = allSettled)]
+    pub fn all_settled(obj: &JsValue) -> Promise;
+
+    /// The `Promise.any(iterable)` method returns a single `Promise` that
+    /// resolves when any of the promises in the iterable argument have resolved
+    /// or when the iterable argument contains no promises. It rejects with an
+    /// `AggregateError` if all promises in the iterable rejected.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/any)
+    #[wasm_bindgen(static_method_of = Promise)]
+    pub fn any(obj: &JsValue) -> Promise;
+
+    /// The `Promise.race(iterable)` method returns a promise that resolves or
+    /// rejects as soon as one of the promises in the iterable resolves or
+    /// rejects, with the value or reason from that promise.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/race)
+    #[wasm_bindgen(static_method_of = Promise)]
+    pub fn race(obj: &JsValue) -> Promise;
+
+    /// The `Promise.reject(reason)` method returns a `Promise` object that is
+    /// rejected with the given reason.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/reject)
+    #[wasm_bindgen(static_method_of = Promise)]
+    pub fn reject(obj: &JsValue) -> Promise;
+
+    /// The `Promise.resolve(value)` method returns a `Promise` object that is
+    /// resolved with the given value. If the value is a promise, that promise
+    /// is returned; if the value is a thenable (i.e. has a "then" method), the
+    /// returned promise will "follow" that thenable, adopting its eventual
+    /// state; otherwise the returned promise will be fulfilled with the value.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/resolve)
+    #[wasm_bindgen(static_method_of = Promise)]
+    pub fn resolve(obj: &JsValue) -> Promise;
+
+    /// The `catch()` method returns a `Promise` and deals with rejected cases
+    /// only.  It behaves the same as calling `Promise.prototype.then(undefined,
+    /// onRejected)` (in fact, calling `obj.catch(onRejected)` internally calls
+    /// `obj.then(undefined, onRejected)`).
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/catch)
+    #[wasm_bindgen(method)]
+    pub fn catch(this: &Promise, cb: &Closure<dyn FnMut(JsValue)>) -> Promise;
+
+    /// The `then()` method returns a `Promise`. It takes up to two arguments:
+    /// callback functions for the success and failure cases of the `Promise`.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/then)
+    #[wasm_bindgen(method)]
+    pub fn then(this: &Promise, cb: &Closure<dyn FnMut(JsValue)>) -> Promise;
+
+    /// Same as `then`, only with both arguments provided.
+    #[wasm_bindgen(method, js_name = then)]
+    pub fn then2(
+        this: &Promise,
+        resolve: &Closure<dyn FnMut(JsValue)>,
+        reject: &Closure<dyn FnMut(JsValue)>,
+    ) -> Promise;
+
+    /// The `finally()` method returns a `Promise`. When the promise is settled,
+    /// whether fulfilled or rejected, the specified callback function is
+    /// executed. This provides a way for code that must be executed once the
+    /// `Promise` has been dealt with to be run whether the promise was
+    /// fulfilled successfully or rejected.
+    ///
+    /// This lets you avoid duplicating code in both the promise's `then()` and
+    /// `catch()` handlers.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/finally)
+    #[wasm_bindgen(method)]
+    pub fn finally(this: &Promise, cb: &Closure<dyn FnMut()>) -> Promise;
+}
+
+/// Returns a handle to the global scope object.
+///
+/// This allows access to the global properties and global names by accessing
+/// the `Object` returned.
+pub fn global() -> Object {
+    thread_local!(static GLOBAL: Object = get_global_object());
+
+    return GLOBAL.with(|g| g.clone());
+
+    fn get_global_object() -> Object {
+        // This is a bit wonky, but we're basically using `#[wasm_bindgen]`
+        // attributes to synthesize imports so we can access properties of the
+        // form:
+        //
+        // * `globalThis.globalThis`
+        // * `self.self`
+        // * ... (etc)
+        //
+        // Accessing the global object is not an easy thing to do, and what we
+        // basically want is `globalThis` but we can't rely on that existing
+        // everywhere. In the meantime we've got the fallbacks mentioned in:
+        //
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis
+        //
+        // Note that this is pretty heavy code-size wise but it at least gets
+        // the job largely done for now and avoids the `Function` constructor at
+        // the end which triggers CSP errors.
+        #[wasm_bindgen]
+        extern "C" {
+            type Global;
+
+            #[wasm_bindgen(getter, catch, static_method_of = Global, js_class = globalThis, js_name = globalThis)]
+            fn get_global_this() -> Result<Object, JsValue>;
+
+            #[wasm_bindgen(getter, catch, static_method_of = Global, js_class = self, js_name = self)]
+            fn get_self() -> Result<Object, JsValue>;
+
+            #[wasm_bindgen(getter, catch, static_method_of = Global, js_class = window, js_name = window)]
+            fn get_window() -> Result<Object, JsValue>;
+
+            #[wasm_bindgen(getter, catch, static_method_of = Global, js_class = global, js_name = global)]
+            fn get_global() -> Result<Object, JsValue>;
+        }
+
+        // The order is important: in Firefox Extension Content Scripts `globalThis`
+        // is a Sandbox (not Window), so `globalThis` must be checked after `window`.
+        let static_object = Global::get_self()
+            .or_else(|_| Global::get_window())
+            .or_else(|_| Global::get_global_this())
+            .or_else(|_| Global::get_global());
+        if let Ok(obj) = static_object {
+            if !obj.is_undefined() {
+                return obj;
+            }
+        }
+
+        // According to StackOverflow you can access the global object via:
+        //
+        //      const global = Function('return this')();
+        //
+        // I think that's because the manufactured function isn't in "strict" mode.
+        // It also turns out that non-strict functions will ignore `undefined`
+        // values for `this` when using the `apply` function.
+        //
+        // As a result we use the equivalent of this snippet to get a handle to the
+        // global object in a sort of roundabout way that should hopefully work in
+        // all contexts like ESM, node, browsers, etc.
+        let this = Function::new_no_args("return this")
+            .call0(&JsValue::undefined())
+            .ok();
+
+        // Note that we avoid `unwrap()` on `call0` to avoid code size bloat, we
+        // just handle the `Err` case as returning a different object.
+        debug_assert!(this.is_some());
+        match this {
+            Some(this) => this.unchecked_into(),
+            None => JsValue::undefined().unchecked_into(),
+        }
+    }
+}
+
+macro_rules! arrays {
+    ($(#[doc = $ctor:literal] #[doc = $mdn:literal] $name:ident: $ty:ident,)*) => ($(
+        #[wasm_bindgen]
+        extern "C" {
+            #[wasm_bindgen(extends = Object, typescript_type = $name)]
+            #[derive(Clone, Debug)]
+            pub type $name;
+
+            /// The
+            #[doc = $ctor]
+            /// constructor creates a new array.
+            ///
+            /// [MDN documentation](
+            #[doc = $mdn]
+            /// )
+            #[wasm_bindgen(constructor)]
+            pub fn new(constructor_arg: &JsValue) -> $name;
+
+            /// An
+            #[doc = $ctor]
+            /// which creates an array with an internal buffer large
+            /// enough for `length` elements.
+            ///
+            /// [MDN documentation](
+            #[doc = $mdn]
+            /// )
+            #[wasm_bindgen(constructor)]
+            pub fn new_with_length(length: u32) -> $name;
+
+            /// An
+            #[doc = $ctor]
+            /// which creates an array with the given buffer but is a
+            /// view starting at `byte_offset`.
+            ///
+            /// [MDN documentation](
+            #[doc = $mdn]
+            /// )
+            #[wasm_bindgen(constructor)]
+            pub fn new_with_byte_offset(buffer: &JsValue, byte_offset: u32) -> $name;
+
+            /// An
+            #[doc = $ctor]
+            /// which creates an array with the given buffer but is a
+            /// view starting at `byte_offset` for `length` elements.
+            ///
+            /// [MDN documentation](
+            #[doc = $mdn]
+            /// )
+            #[wasm_bindgen(constructor)]
+            pub fn new_with_byte_offset_and_length(
+                buffer: &JsValue,
+                byte_offset: u32,
+                length: u32,
+            ) -> $name;
+
+            /// The `fill()` method fills all the elements of an array from a start index
+            /// to an end index with a static value. The end index is not included.
+            ///
+            /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill)
+            #[wasm_bindgen(method)]
+            pub fn fill(this: &$name, value: $ty, start: u32, end: u32) -> $name;
+
+            /// The buffer accessor property represents the `ArrayBuffer` referenced
+            /// by a `TypedArray` at construction time.
+            #[wasm_bindgen(getter, method)]
+            pub fn buffer(this: &$name) -> ArrayBuffer;
+
+            /// The `subarray()` method returns a new `TypedArray` on the same
+            /// `ArrayBuffer` store and with the same element types as for this
+            /// `TypedArray` object.
+            #[wasm_bindgen(method)]
+            pub fn subarray(this: &$name, begin: u32, end: u32) -> $name;
+
+            /// The `slice()` method returns a shallow copy of a portion of a typed
+            /// array into a new typed array object. This method has the same algorithm
+            /// as `Array.prototype.slice()`.
+            #[wasm_bindgen(method)]
+            pub fn slice(this: &$name, begin: u32, end: u32) -> $name;
+
+            /// The `forEach()` method executes a provided function once per array
+            /// element. This method has the same algorithm as
+            /// `Array.prototype.forEach()`. `TypedArray` is one of the typed array
+            /// types here.
+            #[wasm_bindgen(method, js_name = forEach)]
+            pub fn for_each(this: &$name, callback: &mut dyn FnMut($ty, u32, $name));
+
+            /// The length accessor property represents the length (in elements) of a
+            /// typed array.
+            #[wasm_bindgen(method, getter)]
+            pub fn length(this: &$name) -> u32;
+
+            /// The byteLength accessor property represents the length (in bytes) of a
+            /// typed array.
+            #[wasm_bindgen(method, getter, js_name = byteLength)]
+            pub fn byte_length(this: &$name) -> u32;
+
+            /// The byteOffset accessor property represents the offset (in bytes) of a
+            /// typed array from the start of its `ArrayBuffer`.
+            #[wasm_bindgen(method, getter, js_name = byteOffset)]
+            pub fn byte_offset(this: &$name) -> u32;
+
+            /// The `set()` method stores multiple values in the typed array, reading
+            /// input values from a specified array.
+            #[wasm_bindgen(method)]
+            pub fn set(this: &$name, src: &JsValue, offset: u32);
+
+            /// Gets the value at `idx`, counting from the end if negative.
+            #[wasm_bindgen(method)]
+            pub fn at(this: &$name, idx: i32) -> Option<$ty>;
+
+            /// Gets the value at `idx`, equivalent to the javascript `my_var = arr[idx]`.
+            #[wasm_bindgen(method, structural, indexing_getter)]
+            pub fn get_index(this: &$name, idx: u32) -> $ty;
+
+            /// Sets the value at `idx`, equivalent to the javascript `arr[idx] = value`.
+            #[wasm_bindgen(method, structural, indexing_setter)]
+            pub fn set_index(this: &$name, idx: u32, value: $ty);
+        }
+
+        impl $name {
+            /// Creates a JS typed array which is a view into wasm's linear
+            /// memory at the slice specified.
+            ///
+            /// This function returns a new typed array which is a view into
+            /// wasm's memory. This view does not copy the underlying data.
+            ///
+            /// # Unsafety
+            ///
+            /// Views into WebAssembly memory are only valid so long as the
+            /// backing buffer isn't resized in JS. Once this function is called
+            /// any future calls to `Box::new` (or malloc of any form) may cause
+            /// the returned value here to be invalidated. Use with caution!
+            ///
+            /// Additionally the returned object can be safely mutated but the
+            /// input slice isn't guaranteed to be mutable.
+            ///
+            /// Finally, the returned object is disconnected from the input
+            /// slice's lifetime, so there's no guarantee that the data is read
+            /// at the right time.
+            pub unsafe fn view(rust: &[$ty]) -> $name {
+                let buf = wasm_bindgen::memory();
+                let mem = buf.unchecked_ref::<WebAssembly::Memory>();
+                $name::new_with_byte_offset_and_length(
+                    &mem.buffer(),
+                    rust.as_ptr() as u32,
+                    rust.len() as u32,
+                )
+            }
+
+            /// Creates a JS typed array which is a view into wasm's linear
+            /// memory at the specified pointer with specified length.
+            ///
+            /// This function returns a new typed array which is a view into
+            /// wasm's memory. This view does not copy the underlying data.
+            ///
+            /// # Unsafety
+            ///
+            /// Views into WebAssembly memory are only valid so long as the
+            /// backing buffer isn't resized in JS. Once this function is called
+            /// any future calls to `Box::new` (or malloc of any form) may cause
+            /// the returned value here to be invalidated. Use with caution!
+            ///
+            /// Additionally the returned object can be safely mutated,
+            /// the changes are guranteed to be reflected in the input array.
+            pub unsafe fn view_mut_raw(ptr: *mut $ty, length: usize) -> $name {
+                let buf = wasm_bindgen::memory();
+                let mem = buf.unchecked_ref::<WebAssembly::Memory>();
+                $name::new_with_byte_offset_and_length(
+                    &mem.buffer(),
+                    ptr as u32,
+                    length as u32
+                )
+            }
+
+
+            /// Copy the contents of this JS typed array into the destination
+            /// Rust pointer.
+            ///
+            /// This function will efficiently copy the memory from a typed
+            /// array into this wasm module's own linear memory, initializing
+            /// the memory destination provided.
+            ///
+            /// # Unsafety
+            ///
+            /// This function requires `dst` to point to a buffer
+            /// large enough to fit this array's contents.
+            pub unsafe fn raw_copy_to_ptr(&self, dst: *mut $ty) {
+                let buf = wasm_bindgen::memory();
+                let mem = buf.unchecked_ref::<WebAssembly::Memory>();
+                let all_wasm_memory = $name::new(&mem.buffer());
+                let offset = dst as usize / mem::size_of::<$ty>();
+                all_wasm_memory.set(self, offset as u32);
+            }
+
+            /// Copy the contents of this JS typed array into the destination
+            /// Rust slice.
+            ///
+            /// This function will efficiently copy the memory from a typed
+            /// array into this wasm module's own linear memory, initializing
+            /// the memory destination provided.
+            ///
+            /// # Panics
+            ///
+            /// This function will panic if this typed array's length is
+            /// different than the length of the provided `dst` array.
+            pub fn copy_to(&self, dst: &mut [$ty]) {
+                assert_eq!(self.length() as usize, dst.len());
+                unsafe { self.raw_copy_to_ptr(dst.as_mut_ptr()); }
+            }
+
+            /// Copy the contents of the source Rust slice into this
+            /// JS typed array.
+            ///
+            /// This function will efficiently copy the memory from within
+            /// the wasm module's own linear memory to this typed array.
+            ///
+            /// # Panics
+            ///
+            /// This function will panic if this typed array's length is
+            /// different than the length of the provided `src` array.
+            pub fn copy_from(&self, src: &[$ty]) {
+                assert_eq!(self.length() as usize, src.len());
+                // This is safe because the `set` function copies from its TypedArray argument
+                unsafe { self.set(&$name::view(src), 0) }
+            }
+
+            /// Efficiently copies the contents of this JS typed array into a new Vec.
+            pub fn to_vec(&self) -> Vec<$ty> {
+                let mut output = Vec::with_capacity(self.length() as usize);
+                unsafe {
+                    self.raw_copy_to_ptr(output.as_mut_ptr());
+                    output.set_len(self.length() as usize);
+                }
+                output
+            }
+        }
+
+        impl<'a> From<&'a [$ty]> for $name {
+            #[inline]
+            fn from(slice: &'a [$ty]) -> $name {
+                // This is safe because the `new` function makes a copy if its argument is a TypedArray
+                unsafe { $name::new(&$name::view(slice)) }
+            }
+        }
+
+        impl Default for $name {
+            fn default() -> Self {
+                Self::new(&JsValue::UNDEFINED.unchecked_into())
+            }
+        }
+    )*);
+}
+
+arrays! {
+    /// `Int8Array()`
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int8Array
+    Int8Array: i8,
+
+    /// `Int16Array()`
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int16Array
+    Int16Array: i16,
+
+    /// `Int32Array()`
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int32Array
+    Int32Array: i32,
+
+    /// `Uint8Array()`
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array
+    Uint8Array: u8,
+
+    /// `Uint8ClampedArray()`
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8ClampedArray
+    Uint8ClampedArray: u8,
+
+    /// `Uint16Array()`
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint16Array
+    Uint16Array: u16,
+
+    /// `Uint32Array()`
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint32Array
+    Uint32Array: u32,
+
+    /// `Float32Array()`
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float32Array
+    Float32Array: f32,
+
+    /// `Float64Array()`
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array
+    Float64Array: f64,
+
+    /// `BigInt64Array()`
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt64Array
+    BigInt64Array: i64,
+
+    /// `BigUint64Array()`
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigUint64Array
+    BigUint64Array: u64,
+}
diff --git a/vendor/js-sys/tests/headless.js b/vendor/js-sys/tests/headless.js
new file mode 100644
index 000000000..ba93a0917
--- /dev/null
+++ b/vendor/js-sys/tests/headless.js
@@ -0,0 +1,3 @@
+export function is_array_values_supported() {
+  return typeof Array.prototype.values === 'function';
+}
diff --git a/vendor/js-sys/tests/headless.rs b/vendor/js-sys/tests/headless.rs
new file mode 100644
index 000000000..aafa6b0ae
--- /dev/null
+++ b/vendor/js-sys/tests/headless.rs
@@ -0,0 +1,47 @@
+#![cfg(target_arch = "wasm32")]
+
+extern crate js_sys;
+extern crate wasm_bindgen;
+extern crate wasm_bindgen_test;
+
+use js_sys::Array;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen_test::*;
+
+wasm_bindgen_test_configure!(run_in_browser);
+
+#[wasm_bindgen(module = "/tests/headless.js")]
+extern "C" {
+    fn is_array_values_supported() -> bool;
+}
+
+#[wasm_bindgen]
+extern "C" {
+    type ValuesIterator;
+    #[wasm_bindgen(method, structural)]
+    fn next(this: &ValuesIterator) -> IterNext;
+
+    type IterNext;
+
+    #[wasm_bindgen(method, getter, structural)]
+    fn value(this: &IterNext) -> JsValue;
+    #[wasm_bindgen(method, getter, structural)]
+    fn done(this: &IterNext) -> bool;
+}
+
+#[wasm_bindgen_test]
+fn array_iterator_values() {
+    if !is_array_values_supported() {
+        return;
+    }
+    let array = Array::new();
+    array.push(&8.into());
+    array.push(&3.into());
+    array.push(&2.into());
+    let iter = ValuesIterator::from(JsValue::from(array.values()));
+
+    assert_eq!(iter.next().value(), 8);
+    assert_eq!(iter.next().value(), 3);
+    assert_eq!(iter.next().value(), 2);
+    assert!(iter.next().done());
+}
diff --git a/vendor/js-sys/tests/wasm/Array.js b/vendor/js-sys/tests/wasm/Array.js
new file mode 100644
index 000000000..f4d6ab713
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Array.js
@@ -0,0 +1,7 @@
+// Used for `Array.rs` tests
+exports.populate_array = function(arr, start, len) {
+  var isBigInt = typeof(arr[0]) === "bigint";
+  for (i = 0; i < len; i++) {
+    arr[i] = isBigInt ? BigInt(start + i) : start + i;
+  }
+};
diff --git a/vendor/js-sys/tests/wasm/Array.rs b/vendor/js-sys/tests/wasm/Array.rs
new file mode 100644
index 000000000..e498c2cc0
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Array.rs
@@ -0,0 +1,647 @@
+use js_sys::*;
+use std::iter::FromIterator;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::JsValue;
+use wasm_bindgen_test::*;
+
+macro_rules! js_array {
+    ($($e:expr),*) => ({
+        let __x = Array::new();
+        $(__x.push(&JsValue::from($e));)*
+        __x
+    })
+}
+
+macro_rules! array {
+    ($($e:expr),*) => ({
+        let mut __x = Vec::new();
+        $(__x.push(JsValue::from($e));)*
+        __x
+    })
+}
+
+fn to_rust(arr: &Array) -> Vec<JsValue> {
+    let mut result = Vec::with_capacity(arr.length() as usize);
+    arr.for_each(&mut |x, _, _| result.push(x));
+    result
+}
+
+#[wasm_bindgen_test]
+fn from_iter() {
+    assert_eq!(
+        to_rust(
+            &vec![JsValue::from("a"), JsValue::from("b"), JsValue::from("c"),]
+                .into_iter()
+                .collect()
+        ),
+        vec!["a", "b", "c"],
+    );
+
+    assert_eq!(
+        to_rust(
+            &vec![JsValue::from("a"), JsValue::from("b"), JsValue::from("c"),]
+                .iter()
+                .collect()
+        ),
+        vec!["a", "b", "c"],
+    );
+
+    let array = js_array![1u32, 2u32, 3u32];
+
+    assert_eq!(
+        to_rust(&vec![array.clone(),].into_iter().collect()),
+        vec![JsValue::from(array.clone())],
+    );
+
+    assert_eq!(
+        to_rust(&vec![array.clone(),].iter().collect()),
+        vec![JsValue::from(array)],
+    );
+
+    assert_eq!(
+        to_rust(&vec![5, 10, 20,].into_iter().map(JsValue::from).collect()),
+        vec![5, 10, 20],
+    );
+
+    assert_eq!(
+        to_rust(&Array::from_iter(&[
+            JsValue::from("a"),
+            JsValue::from("b"),
+            JsValue::from("c"),
+        ])),
+        vec!["a", "b", "c"],
+    );
+
+    let v = vec!["a", "b", "c"];
+
+    assert_eq!(
+        to_rust(&Array::from_iter(v.into_iter().map(|s| JsValue::from(s)))),
+        vec!["a", "b", "c"],
+    );
+}
+
+#[wasm_bindgen_test]
+fn extend() {
+    let mut array = array!["a", "b"];
+    array.extend(vec![JsValue::from("c"), JsValue::from("d")]);
+    assert_eq!(array, array!["a", "b", "c", "d"]);
+}
+
+#[wasm_bindgen_test]
+fn to_vec() {
+    let array = vec![JsValue::from("a"), JsValue::from("b"), JsValue::from("c")]
+        .into_iter()
+        .collect::<js_sys::Array>();
+
+    assert_eq!(
+        array.to_vec(),
+        vec![JsValue::from("a"), JsValue::from("b"), JsValue::from("c")]
+    );
+}
+
+#[wasm_bindgen_test]
+fn iter() {
+    let array = vec![JsValue::from("a"), JsValue::from("b"), JsValue::from("c")]
+        .into_iter()
+        .collect::<js_sys::Array>();
+
+    assert_eq!(
+        array.iter().collect::<Vec<JsValue>>(),
+        vec![JsValue::from("a"), JsValue::from("b"), JsValue::from("c")]
+    );
+
+    let mut iter = array.iter();
+
+    assert_eq!(iter.size_hint(), (3, Some(3)));
+    assert_eq!(iter.next(), Some(JsValue::from("a")));
+
+    assert_eq!(iter.size_hint(), (2, Some(2)));
+    assert_eq!(iter.next_back(), Some(JsValue::from("c")));
+
+    assert_eq!(iter.size_hint(), (1, Some(1)));
+    assert_eq!(iter.next_back(), Some(JsValue::from("b")));
+
+    assert_eq!(iter.size_hint(), (0, Some(0)));
+    assert_eq!(iter.next(), None);
+
+    assert_eq!(iter.size_hint(), (0, Some(0)));
+    assert_eq!(iter.next_back(), None);
+
+    let mut iter = array.iter();
+
+    assert_eq!(iter.size_hint(), (3, Some(3)));
+    assert_eq!(iter.next(), Some(JsValue::from("a")));
+
+    assert_eq!(iter.size_hint(), (2, Some(2)));
+    assert_eq!(iter.next(), Some(JsValue::from("b")));
+
+    assert_eq!(iter.size_hint(), (1, Some(1)));
+    assert_eq!(iter.next(), Some(JsValue::from("c")));
+
+    assert_eq!(iter.size_hint(), (0, Some(0)));
+    assert_eq!(iter.next(), None);
+
+    let mut iter = array.iter();
+
+    assert_eq!(iter.size_hint(), (3, Some(3)));
+    assert_eq!(iter.next_back(), Some(JsValue::from("c")));
+
+    assert_eq!(iter.size_hint(), (2, Some(2)));
+    assert_eq!(iter.next_back(), Some(JsValue::from("b")));
+
+    assert_eq!(iter.size_hint(), (1, Some(1)));
+    assert_eq!(iter.next_back(), Some(JsValue::from("a")));
+
+    assert_eq!(iter.size_hint(), (0, Some(0)));
+    assert_eq!(iter.next_back(), None);
+}
+
+#[wasm_bindgen_test]
+fn new_with_length() {
+    let array = Array::new_with_length(5);
+    assert_eq!(array.length(), 5);
+    assert_eq!(array.get(4), JsValue::undefined());
+    array.set(4, JsValue::from("a"));
+    assert_eq!(array.get(4), "a");
+    assert_eq!(array.length(), 5);
+}
+
+#[wasm_bindgen_test]
+fn get() {
+    let array = js_array!["a", "c", "x", "n"];
+    assert_eq!(array.length(), 4);
+    assert_eq!(array.get(0), "a");
+    assert_eq!(array.get(3), "n");
+    assert_eq!(array.get(4), JsValue::undefined());
+}
+
+#[wasm_bindgen_test]
+fn set() {
+    let array = js_array!["a", "c", "x", "n"];
+    assert_eq!(array.length(), 4);
+    assert_eq!(array.get(0), "a");
+    array.set(0, JsValue::from("b"));
+    assert_eq!(array.get(0), "b");
+
+    assert_eq!(array.get(4), JsValue::undefined());
+    assert_eq!(array.length(), 4);
+    array.set(4, JsValue::from("d"));
+    assert_eq!(array.length(), 5);
+    assert_eq!(array.get(4), "d");
+
+    assert_eq!(array.get(10), JsValue::undefined());
+    assert_eq!(array.length(), 5);
+    array.set(10, JsValue::from("z"));
+    assert_eq!(array.length(), 11);
+    assert_eq!(array.get(10), "z");
+    assert_eq!(array.get(9), JsValue::undefined());
+}
+
+#[wasm_bindgen_test]
+fn delete() {
+    let array = js_array!["a", "c", "x", "n"];
+    assert_eq!(array.length(), 4);
+    assert_eq!(array.get(0), "a");
+    array.delete(0);
+    assert_eq!(array.get(0), JsValue::undefined());
+}
+
+#[wasm_bindgen_test]
+fn filter() {
+    let array = js_array!["a", "c", "x", "n"];
+    assert!(array.filter(&mut |x, _, _| x.as_f64().is_some()).length() == 0);
+
+    let array = js_array![1, 2, 3, 4];
+    assert_eq!(
+        array.filter(&mut |x, _, _| x.as_f64().is_some()).length(),
+        4
+    );
+
+    let array = js_array!["a", 1, "b", 2];
+    assert_eq!(
+        array.filter(&mut |x, _, _| x.as_f64().is_some()).length(),
+        2
+    );
+}
+
+#[wasm_bindgen_test]
+fn flat() {
+    let array = js_array![
+        js_array!["a", "b", "c"],
+        "d",
+        js_array!["e", js_array!["f", "g"]]
+    ];
+
+    assert_eq!(
+        to_rust(&array.flat(1).slice(0, 5)),
+        vec!["a", "b", "c", "d", "e"]
+    );
+
+    assert_eq!(array.flat(1).length(), 6);
+
+    assert_eq!(
+        to_rust(&array.flat(2)),
+        vec!["a", "b", "c", "d", "e", "f", "g"]
+    );
+}
+
+#[wasm_bindgen_test]
+fn flat_map() {
+    let array = js_array![1, 2, 3, 1];
+
+    assert_eq!(
+        to_rust(
+            &array.flat_map(&mut |val, _, _| match val.as_f64().map(|v| v as i32) {
+                Some(1) => vec![JsString::from("x").into(), JsString::from("x").into()],
+                Some(2) => vec![],
+                Some(3) => vec![JsString::from("z").into()],
+                _ => panic!("Unexpected conversion"),
+            })
+        ),
+        vec!["x", "x", "z", "x", "x"]
+    );
+}
+
+#[wasm_bindgen_test]
+fn index_of() {
+    let chars = js_array!["a", "c", "x", "n"];
+    assert_eq!(chars.index_of(&"x".into(), 0), 2);
+    assert_eq!(chars.index_of(&"z".into(), 0), -1);
+    assert_eq!(chars.index_of(&"x".into(), -3), 2);
+    assert_eq!(chars.index_of(&"z".into(), -2), -1);
+}
+
+#[wasm_bindgen_test]
+fn is_array() {
+    assert!(Array::is_array(&Array::new().into()));
+    assert!(Array::is_array(&js_array![1].into()));
+    assert!(!Array::is_array(&JsValue::null()));
+    assert!(!Array::is_array(&JsValue::undefined()));
+    assert!(!Array::is_array(&10.into()));
+    assert!(!Array::is_array(&"x".into()));
+    assert!(!Array::is_array(&true.into()));
+    assert!(!Array::is_array(&false.into()));
+}
+
+#[wasm_bindgen_test]
+fn sort() {
+    let array = js_array![3, 1, 6, 2];
+    let sorted = array.sort();
+    assert_eq!(to_rust(&sorted), array![1, 2, 3, 6]);
+}
+
+#[wasm_bindgen_test]
+fn some() {
+    let array = js_array!["z", 1, "y", 2];
+    assert!(array.some(&mut |e| e == JsValue::from(2)));
+    assert!(array.some(&mut |e| e == JsValue::from("y")));
+    assert!(!array.some(&mut |e| e == JsValue::from("nope")));
+}
+
+#[wasm_bindgen_test]
+fn last_index_of() {
+    let characters = js_array!["a", "x", "c", "x", "n"];
+    assert_eq!(characters.last_index_of(&"x".into(), 5), 3);
+    assert_eq!(characters.last_index_of(&"z".into(), 5), -1);
+    assert_eq!(characters.last_index_of(&"x".into(), 2), 1);
+    assert_eq!(characters.last_index_of(&"x".into(), 0), -1);
+}
+
+#[wasm_bindgen_test]
+fn join() {
+    let characters = js_array!["a", "c", "x", "n"];
+    assert_eq!(String::from(characters.join(", ")), "a, c, x, n");
+    assert_eq!(String::from(characters.join("/")), "a/c/x/n");
+}
+
+#[wasm_bindgen_test]
+fn slice() {
+    let characters = js_array!["a", "c", "x", "n", 1, "8"];
+    let subset = characters.slice(1, 3);
+
+    assert_eq!(to_rust(&subset), array!["c", "x"]);
+}
+
+#[wasm_bindgen_test]
+fn splice() {
+    let characters = js_array!["a", "c", "x", "n", 1, "8"];
+    let removed = characters.splice(1, 3, &"b".into());
+
+    assert_eq!(to_rust(&removed), array!["c", "x", "n"]);
+    assert_eq!(to_rust(&characters), array!["a", "b", 1, "8"]);
+}
+
+#[wasm_bindgen_test]
+fn fill() {
+    let characters = js_array!["a", "c", "x", "n", 1, "8"];
+    let subset = characters.fill(&0.into(), 0, 3);
+
+    assert_eq!(to_rust(&subset), array![0, 0, 0, "n", 1, "8"]);
+}
+
+#[wasm_bindgen_test]
+fn copy_within() {
+    let characters = js_array![8, 5, 4, 3, 1, 2];
+    characters.copy_within(1, 4, 5);
+
+    assert_eq!(to_rust(&characters)[1], JsValue::from(1));
+
+    // if negatives were used
+    characters.copy_within(-1, -3, -2);
+    assert_eq!(to_rust(&characters)[5], JsValue::from(3));
+}
+
+#[wasm_bindgen_test]
+fn of() {
+    let a = JsValue::from("a");
+    let b = JsValue::from("b");
+    let c = JsValue::from("c");
+    let arr = Array::of3(&a, &b, &c);
+    let vec = to_rust(&arr);
+    assert_eq!(vec.len(), 3);
+    assert_eq!(vec[0], a);
+    assert_eq!(vec[1], b);
+    assert_eq!(vec[2], c);
+}
+
+#[wasm_bindgen_test]
+fn pop() {
+    let characters = js_array![8, 5, 4, 3, 1, 2];
+    let item = characters.pop();
+    assert_eq!(item, JsValue::from(2));
+    assert_eq!(characters.length(), 5);
+}
+
+#[wasm_bindgen_test]
+fn push() {
+    let characters = js_array![8, 5, 4, 3, 1, 2];
+    let length = characters.push(&"a".into());
+    assert_eq!(length, 7);
+    assert_eq!(to_rust(&characters)[6], "a");
+}
+
+#[wasm_bindgen_test]
+fn reverse() {
+    let characters = js_array![8, 5, 4, 3, 1, 2];
+    let reversed = characters.reverse();
+    assert_eq!(to_rust(&reversed), array![2, 1, 3, 4, 5, 8]);
+}
+
+#[wasm_bindgen_test]
+fn shift() {
+    let characters = js_array![8, 5, 4, 3, 1, 2];
+    let shiftedItem = characters.shift();
+
+    assert_eq!(shiftedItem, 8);
+    assert_eq!(characters.length(), 5);
+}
+
+#[wasm_bindgen_test]
+fn unshift() {
+    let characters = js_array![8, 5, 4, 3, 1, 2];
+    let length = characters.unshift(&"abba".into());
+
+    assert_eq!(length, 7);
+    assert_eq!(to_rust(&characters)[0], "abba");
+}
+
+#[wasm_bindgen_test]
+fn to_string() {
+    let characters = js_array![8, 5, 4, 3, 1, 2];
+    assert_eq!(String::from(characters.to_string()), "8,5,4,3,1,2");
+}
+
+#[wasm_bindgen_test]
+fn includes() {
+    let characters = js_array![8, 5, 4, 3, 1, 2];
+    assert!(characters.includes(&2.into(), 0));
+    assert!(!characters.includes(&9.into(), 0));
+    assert!(!characters.includes(&3.into(), 4));
+}
+
+#[wasm_bindgen_test]
+fn concat() {
+    let arr1 = js_array![1, 2, 3];
+    let arr2 = js_array![4, 5, 6];
+
+    let new_array = arr1.concat(&arr2);
+    assert_eq!(to_rust(&new_array), array![1, 2, 3, 4, 5, 6]);
+}
+
+#[wasm_bindgen_test]
+fn length() {
+    let characters = js_array![8, 5, 4, 3, 1, 2];
+    assert_eq!(characters.length(), 6);
+    assert_eq!(Array::new().length(), 0);
+}
+
+#[wasm_bindgen_test]
+fn every() {
+    let even = js_array![2, 4, 6, 8];
+    assert!(even.every(&mut |x, _, _| x.as_f64().unwrap() % 2.0 == 0.0));
+    let odd = js_array![1, 3, 5, 7];
+    assert!(!odd.every(&mut |x, _, _| x.as_f64().unwrap() % 2.0 == 0.0));
+    let mixed = js_array![2, 3, 4, 5];
+    assert!(!mixed.every(&mut |x, _, _| x.as_f64().unwrap() % 2.0 == 0.0));
+}
+
+#[wasm_bindgen_test]
+fn find() {
+    let even = js_array![2, 4, 6, 8];
+    assert_eq!(
+        even.find(&mut |x, _, _| x.as_f64().unwrap() % 2.0 == 0.0),
+        2
+    );
+    let odd = js_array![1, 3, 5, 7];
+    assert_eq!(
+        odd.find(&mut |x, _, _| x.as_f64().unwrap() % 2.0 == 0.0),
+        JsValue::undefined(),
+    );
+    let mixed = js_array![3, 5, 7, 10];
+    assert_eq!(
+        mixed.find(&mut |x, _, _| x.as_f64().unwrap() % 2.0 == 0.0),
+        10
+    );
+}
+
+#[wasm_bindgen_test]
+fn map() {
+    let numbers = js_array![1, 4, 9];
+    let sqrt = numbers.map(&mut |x, _, _| x.as_f64().unwrap().sqrt().into());
+    assert_eq!(to_rust(&sqrt), array![1, 2, 3]);
+}
+
+#[wasm_bindgen_test]
+fn reduce() {
+    let arr = js_array!["0", "1", "2", "3", "4"].reduce(
+        &mut |ac, cr, _, _| {
+            format!("{}{}", &ac.as_string().unwrap(), &cr.as_string().unwrap()).into()
+        },
+        &"".into(),
+    );
+    assert_eq!(arr, "01234");
+}
+
+#[wasm_bindgen_test]
+fn reduce_right() {
+    let arr = js_array!["0", "1", "2", "3", "4"].reduce_right(
+        &mut |ac, cr, _, _| {
+            format!("{}{}", &ac.as_string().unwrap(), &cr.as_string().unwrap()).into()
+        },
+        &"".into(),
+    );
+    assert_eq!(arr, "43210");
+}
+
+#[wasm_bindgen_test]
+fn find_index() {
+    let even = js_array![2, 4, 6, 8];
+    assert_eq!(
+        even.find_index(&mut |e, _, _| e.as_f64().unwrap() % 2. == 0.),
+        0
+    );
+    let odd = js_array![1, 3, 5, 7];
+    assert_eq!(
+        odd.find_index(&mut |e, _, _| e.as_f64().unwrap() % 2. == 0.),
+        -1
+    );
+    let mixed = js_array![3, 5, 7, 10];
+    assert_eq!(
+        mixed.find_index(&mut |e, _, _| e.as_f64().unwrap() % 2. == 0.),
+        3
+    );
+}
+
+#[wasm_bindgen_test]
+fn to_locale_string() {
+    let output = js_array![1, "a", Date::new(&"21 Dec 1997 14:12:00 UTC".into())]
+        .to_locale_string(&"en".into(), &JsValue::undefined());
+    assert!(String::from(output).len() > 0);
+}
+
+#[wasm_bindgen_test]
+fn for_each() {
+    fn sum_indices_of_evens(array: &Array) -> u32 {
+        let mut res = 0;
+        array.for_each(&mut |elem: JsValue, i, _| match elem.as_f64() {
+            Some(val) if val % 2. == 0. => res += i,
+            _ => {}
+        });
+        res
+    }
+
+    assert_eq!(sum_indices_of_evens(&js_array![2, 4, 6, 8]), 0 + 1 + 2 + 3);
+    assert_eq!(sum_indices_of_evens(&js_array![1, 3, 5, 7]), 0);
+    assert_eq!(sum_indices_of_evens(&js_array![3, 5, 7, 10]), 3);
+}
+
+#[wasm_bindgen_test]
+fn array_inheritance() {
+    let array = Array::new();
+    assert!(array.is_instance_of::<Array>());
+    assert!(array.is_instance_of::<Object>());
+    let _: &Object = array.as_ref();
+}
+
+#[wasm_bindgen(module = "tests/wasm/Array.js")]
+extern "C" {
+    fn populate_array(arr: JsValue, start: JsValue, len: JsValue) -> JsValue;
+}
+
+fn test_array_view_mut_raw<ElemT: std::cmp::PartialEq + std::fmt::Debug, ArrT>(
+    sut: unsafe fn(*mut ElemT, usize) -> ArrT,
+    u8ToElem: fn(u8) -> ElemT,
+    arrToJsValue: fn(ArrT) -> JsValue,
+) {
+    let start: u8 = 10;
+    let len: usize = 32;
+    let end: u8 = start + len as u8;
+    let mut buffer: Vec<ElemT> = Vec::new();
+    buffer.reserve(len);
+    unsafe {
+        let array: ArrT = sut(buffer.as_mut_ptr(), len);
+        populate_array(
+            arrToJsValue(array),
+            JsValue::from(start),
+            JsValue::from(len as u32),
+        );
+        buffer.set_len(len);
+    }
+    let expected: Vec<ElemT> = (start..end).map(u8ToElem).collect();
+    assert_eq!(buffer, expected)
+}
+
+#[wasm_bindgen_test]
+fn Int8Array_view_mut_raw() {
+    fn u8Toi8_unsafe(x: u8) -> i8 {
+        x as i8
+    }
+    test_array_view_mut_raw(
+        js_sys::Int8Array::view_mut_raw,
+        u8Toi8_unsafe,
+        JsValue::from,
+    );
+}
+
+#[wasm_bindgen_test]
+fn Int16Array_view_mut_raw() {
+    test_array_view_mut_raw(js_sys::Int16Array::view_mut_raw, i16::from, JsValue::from);
+}
+
+#[wasm_bindgen_test]
+fn Int32Array_view_mut_raw() {
+    test_array_view_mut_raw(js_sys::Int32Array::view_mut_raw, i32::from, JsValue::from);
+}
+
+#[wasm_bindgen_test]
+fn BigInt64Array_view_mut_raw() {
+    test_array_view_mut_raw(
+        js_sys::BigInt64Array::view_mut_raw,
+        i64::from,
+        JsValue::from,
+    );
+}
+
+#[wasm_bindgen_test]
+fn Uint8Array_view_mut_raw() {
+    test_array_view_mut_raw(js_sys::Uint8Array::view_mut_raw, u8::from, JsValue::from);
+}
+
+#[wasm_bindgen_test]
+fn Uint8ClampedArray_view_mut_raw() {
+    test_array_view_mut_raw(
+        js_sys::Uint8ClampedArray::view_mut_raw,
+        u8::from,
+        JsValue::from,
+    );
+}
+
+#[wasm_bindgen_test]
+fn Uint16Array_view_mut_raw() {
+    test_array_view_mut_raw(js_sys::Uint16Array::view_mut_raw, u16::from, JsValue::from);
+}
+
+#[wasm_bindgen_test]
+fn Uint32Array_view_mut_raw() {
+    test_array_view_mut_raw(js_sys::Uint32Array::view_mut_raw, u32::from, JsValue::from);
+}
+
+#[wasm_bindgen_test]
+fn BigUint64Array_view_mut_raw() {
+    test_array_view_mut_raw(
+        js_sys::BigUint64Array::view_mut_raw,
+        u64::from,
+        JsValue::from,
+    );
+}
+
+#[wasm_bindgen_test]
+fn Float32Array_view_mut_raw() {
+    test_array_view_mut_raw(js_sys::Float32Array::view_mut_raw, f32::from, JsValue::from);
+}
+
+#[wasm_bindgen_test]
+fn Float64Array_view_mut_raw() {
+    test_array_view_mut_raw(js_sys::Float64Array::view_mut_raw, f64::from, JsValue::from);
+}
diff --git a/vendor/js-sys/tests/wasm/ArrayBuffer.rs b/vendor/js-sys/tests/wasm/ArrayBuffer.rs
new file mode 100644
index 000000000..1bf099aef
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/ArrayBuffer.rs
@@ -0,0 +1,45 @@
+use js_sys::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::JsValue;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen_test]
+fn new() {
+    let x = ArrayBuffer::new(42);
+    let y: JsValue = x.into();
+    assert!(y.is_object());
+}
+
+#[wasm_bindgen_test]
+fn byte_length() {
+    let buf = ArrayBuffer::new(42);
+    assert_eq!(buf.byte_length(), 42);
+}
+
+#[wasm_bindgen_test]
+fn is_view() {
+    let x = Uint8Array::new(&JsValue::from(42));
+    assert!(ArrayBuffer::is_view(&JsValue::from(x)));
+}
+
+#[wasm_bindgen_test]
+fn slice() {
+    let buf = ArrayBuffer::new(4);
+    let slice = buf.slice(2);
+    assert!(JsValue::from(slice).is_object());
+}
+
+#[wasm_bindgen_test]
+fn slice_with_end() {
+    let buf = ArrayBuffer::new(4);
+    let slice = buf.slice_with_end(1, 2);
+    assert!(JsValue::from(slice).is_object());
+}
+
+#[wasm_bindgen_test]
+fn arraybuffer_inheritance() {
+    let buf = ArrayBuffer::new(4);
+    assert!(buf.is_instance_of::<ArrayBuffer>());
+    assert!(buf.is_instance_of::<Object>());
+    let _: &Object = buf.as_ref();
+}
diff --git a/vendor/js-sys/tests/wasm/ArrayIterator.rs b/vendor/js-sys/tests/wasm/ArrayIterator.rs
new file mode 100644
index 000000000..87e67fd2c
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/ArrayIterator.rs
@@ -0,0 +1,39 @@
+use js_sys::*;
+use wasm_bindgen::JsValue;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen_test]
+fn keys() {
+    let array = Array::new();
+    array.push(&JsValue::from(1));
+    array.push(&JsValue::from(2));
+    array.push(&JsValue::from(3));
+    array.push(&JsValue::from(4));
+    array.push(&JsValue::from(5));
+
+    let new_array = Array::from(&array.keys().into());
+
+    let mut result = Vec::new();
+    new_array.for_each(&mut |i, _, _| result.push(i.as_f64().unwrap()));
+    assert_eq!(result, [0.0, 1.0, 2.0, 3.0, 4.0]);
+}
+
+#[wasm_bindgen_test]
+fn entries() {
+    let array = Array::new();
+    array.push(&JsValue::from(1));
+    array.push(&JsValue::from(2));
+    array.push(&JsValue::from(3));
+    array.push(&JsValue::from(4));
+    array.push(&JsValue::from(5));
+
+    let new_array = Array::from(&array.entries().into());
+
+    new_array.for_each(&mut |a, i, _| {
+        assert!(a.is_object());
+        let array: Array = a.into();
+        assert_eq!(array.shift().as_f64().unwrap(), i as f64);
+        assert_eq!(array.shift().as_f64().unwrap(), (i + 1) as f64);
+        assert_eq!(array.length(), 0);
+    });
+}
diff --git a/vendor/js-sys/tests/wasm/BigInt.rs b/vendor/js-sys/tests/wasm/BigInt.rs
new file mode 100644
index 000000000..a9cd30dfb
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/BigInt.rs
@@ -0,0 +1,43 @@
+use js_sys::BigInt;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen_test::wasm_bindgen_test;
+
+/// `assert_eq!`, but the arguments are converted to `JsValue`s.
+#[track_caller]
+fn assert_jsvalue_eq(a: impl Into<JsValue>, b: impl Into<JsValue>) {
+    assert_eq!(a.into(), b.into());
+}
+
+#[wasm_bindgen_test]
+fn from() {
+    // Test that all the `From` impls work properly.
+    assert_jsvalue_eq(BigInt::from(1u8), 1u64);
+    assert_jsvalue_eq(BigInt::from(1u16), 1u64);
+    assert_jsvalue_eq(BigInt::from(1u32), 1u64);
+    assert_jsvalue_eq(BigInt::from(1u64), 1u64);
+    assert_jsvalue_eq(BigInt::from(1u128), 1u64);
+    assert_jsvalue_eq(BigInt::from(1usize), 1u64);
+    assert_jsvalue_eq(BigInt::from(-3i8), -3i64);
+    assert_jsvalue_eq(BigInt::from(-3i16), -3i64);
+    assert_jsvalue_eq(BigInt::from(-3i32), -3i64);
+    assert_jsvalue_eq(BigInt::from(-3i64), -3i64);
+    assert_jsvalue_eq(BigInt::from(-3i128), -3i64);
+    assert_jsvalue_eq(BigInt::from(-3isize), -3i64);
+}
+
+#[wasm_bindgen_test]
+fn eq() {
+    // Test that all the `Eq` impls work properly.
+    assert_eq!(BigInt::from(1u64), 1u8);
+    assert_eq!(BigInt::from(1u64), 1u16);
+    assert_eq!(BigInt::from(1u64), 1u32);
+    assert_eq!(BigInt::from(1u64), 1u64);
+    assert_eq!(BigInt::from(1u64), 1u128);
+    assert_eq!(BigInt::from(1u64), 1usize);
+    assert_eq!(BigInt::from(-3i64), -3i8);
+    assert_eq!(BigInt::from(-3i64), -3i16);
+    assert_eq!(BigInt::from(-3i64), -3i32);
+    assert_eq!(BigInt::from(-3i64), -3i64);
+    assert_eq!(BigInt::from(-3i64), -3i128);
+    assert_eq!(BigInt::from(-3i64), -3isize);
+}
diff --git a/vendor/js-sys/tests/wasm/Boolean.rs b/vendor/js-sys/tests/wasm/Boolean.rs
new file mode 100644
index 000000000..5e4b3faa4
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Boolean.rs
@@ -0,0 +1,25 @@
+use js_sys::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::JsValue;
+use wasm_bindgen_test::*;
+
+#[allow(deprecated)]
+#[wasm_bindgen_test]
+fn new_undefined() {
+    assert_eq!(Boolean::new(&JsValue::undefined()).value_of(), false);
+}
+
+#[allow(deprecated)]
+#[wasm_bindgen_test]
+fn new_truely() {
+    assert_eq!(Boolean::new(&JsValue::from("foo")).value_of(), true);
+}
+
+#[allow(deprecated)]
+#[wasm_bindgen_test]
+fn boolean_inheritance() {
+    let b = Boolean::new(&JsValue::from(true));
+    assert!(b.is_instance_of::<Boolean>());
+    assert!(b.is_instance_of::<Object>());
+    let _: &Object = b.as_ref();
+}
diff --git a/vendor/js-sys/tests/wasm/DataView.rs b/vendor/js-sys/tests/wasm/DataView.rs
new file mode 100644
index 000000000..7747019a5
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/DataView.rs
@@ -0,0 +1,84 @@
+use js_sys::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::JsValue;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen_test]
+fn test() {
+    let bytes = Int8Array::new(&JsValue::from(10));
+
+    // TODO: figure out how to do `bytes[2] = 2`
+    bytes.subarray(2, 3).fill(2, 0, 1);
+
+    let v = DataView::new(&bytes.buffer(), 2, 8);
+    assert_eq!(v.byte_offset(), 2);
+    assert_eq!(v.byte_length(), 8);
+    assert_eq!(v.get_int8(0), 2);
+    assert_eq!(v.get_uint8(0), 2);
+
+    v.set_int8(0, 42);
+    assert_eq!(v.get_int8(0), 42);
+    v.set_uint8(0, 255);
+    assert_eq!(v.get_uint8(0), 255);
+
+    v.set_int16(0, 32767);
+    assert_eq!(v.get_int16(0), 32767);
+    v.set_int16_endian(0, 0x1122, true);
+    assert_eq!(v.get_int16_endian(0, true), 0x1122);
+    assert_eq!(v.get_int16_endian(0, false), 0x2211);
+    v.set_uint16(0, 65535);
+    assert_eq!(v.get_uint16(0), 65535);
+    v.set_uint16_endian(0, 0x1122, true);
+    assert_eq!(v.get_uint16_endian(0, true), 0x1122);
+    assert_eq!(v.get_uint16_endian(0, false), 0x2211);
+
+    v.set_int32(0, 123456789);
+    assert_eq!(v.get_int32(0), 123456789);
+    v.set_int32_endian(0, 0x11223344, true);
+    assert_eq!(v.get_int32_endian(0, true), 0x11223344);
+    assert_eq!(v.get_int32_endian(0, false), 0x44332211);
+    v.set_uint32(0, 3_123_456_789);
+    assert_eq!(v.get_uint32(0), 3_123_456_789);
+    v.set_uint32_endian(0, 0x11223344, true);
+    assert_eq!(v.get_uint32_endian(0, true), 0x11223344);
+    assert_eq!(v.get_uint32_endian(0, false), 0x44332211);
+
+    v.set_float32(0, 100.123);
+    assert_eq!(v.get_float32(0), 100.123);
+    v.set_float32_endian(0, f32::from_bits(0x11223344), true);
+    assert_eq!(v.get_float32_endian(0, true), f32::from_bits(0x11223344));
+    assert_eq!(v.get_float32_endian(0, false), f32::from_bits(0x44332211));
+
+    v.set_float64(0, 123456789.123456);
+    assert_eq!(v.get_float64(0), 123456789.123456);
+    v.set_float64_endian(0, f64::from_bits(0x1122334411223344), true);
+    assert_eq!(
+        v.get_float64_endian(0, true),
+        f64::from_bits(0x1122334411223344)
+    );
+    assert_eq!(
+        v.get_float64_endian(0, false),
+        f64::from_bits(0x4433221144332211)
+    );
+
+    v.set_int8(0, 42);
+
+    // TODO: figure out how to do `bytes[2]`
+    bytes
+        .subarray(2, 3)
+        .for_each(&mut |x, _, _| assert_eq!(x, 42));
+}
+
+#[wasm_bindgen_test]
+fn dataview_inheritance() {
+    let bytes = Int8Array::new(&JsValue::from(10));
+
+    // TODO: figure out how to do `bytes[2] = 2`
+    bytes.subarray(2, 3).fill(2, 0, 1);
+
+    let v = DataView::new(&bytes.buffer(), 2, 8);
+
+    assert!(v.is_instance_of::<DataView>());
+    assert!(v.is_instance_of::<Object>());
+    let _: &Object = v.as_ref();
+}
diff --git a/vendor/js-sys/tests/wasm/Date.rs b/vendor/js-sys/tests/wasm/Date.rs
new file mode 100644
index 000000000..484498d47
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Date.rs
@@ -0,0 +1,530 @@
+use js_sys::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::JsValue;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen_test]
+fn get_date() {
+    let date = Date::new(&"August 19, 1975 23:15:30".into());
+    assert_eq!(date.get_date(), 19);
+}
+
+#[wasm_bindgen_test]
+fn get_day() {
+    let date = Date::new(&"August 19, 1975 23:15:30".into());
+    assert_eq!(date.get_day(), 2);
+}
+
+#[wasm_bindgen_test]
+fn get_full_year() {
+    let date = Date::new(&"July 20, 1969 00:20:18".into());
+    let abbr = Date::new(&"Thu, 06 Sep 12 00:00:00".into());
+
+    assert_eq!(date.get_full_year(), 1969);
+    assert_eq!(abbr.get_full_year(), 2012);
+}
+
+#[wasm_bindgen_test]
+fn get_hours() {
+    let date = Date::new(&"March 13, 08 04:20".into());
+    assert_eq!(date.get_hours(), 4);
+}
+
+#[wasm_bindgen_test]
+fn get_milliseconds() {
+    let date = Date::new(&"1995-12-17T09:24:00Z".into());
+    let ms = Date::new(&"1995-12-17T09:24:00.123Z".into());
+
+    assert_eq!(date.get_milliseconds(), 0);
+    assert_eq!(ms.get_milliseconds(), 123);
+}
+
+#[wasm_bindgen_test]
+fn get_minutes() {
+    let date = Date::new(&"March 13, 08 04:20".into());
+
+    assert_eq!(date.get_minutes(), 20);
+}
+
+#[wasm_bindgen_test]
+fn get_month() {
+    let date = Date::new(&"July 20, 69 00:20:18".into());
+
+    assert_eq!(date.get_month(), 6);
+}
+
+#[wasm_bindgen_test]
+fn get_seconds() {
+    let date = Date::new(&"July 20, 69 00:20:18".into());
+
+    assert_eq!(date.get_seconds(), 18);
+}
+
+#[wasm_bindgen_test]
+fn get_time() {
+    let date = Date::new(&"July 20, 69 00:20:18 GMT+00:00".into());
+
+    assert_eq!(date.get_time(), -14254782000.0);
+}
+
+#[wasm_bindgen_test]
+fn get_timezone_offset() {
+    let date1 = Date::new(&"August 19, 1975 23:15:30 GMT+07:00".into());
+    let date2 = Date::new(&"August 19, 1975 23:15:30 GMT-02:00".into());
+    assert_eq!(date1.get_timezone_offset(), date2.get_timezone_offset());
+}
+
+#[wasm_bindgen_test]
+fn get_utc_date() {
+    let date1 = Date::new(&"August 19, 1975 23:15:30 GMT+11:00".into());
+    let date2 = Date::new(&"August 19, 1975 23:15:30 GMT-11:00".into());
+    assert_eq!(date1.get_utc_date(), 19);
+    assert_eq!(date2.get_utc_date(), 20);
+}
+
+#[wasm_bindgen_test]
+fn get_utc_day() {
+    let date1 = Date::new(&"August 19, 1975 23:15:30 GMT+11:00".into());
+    let date2 = Date::new(&"August 19, 1975 23:15:30 GMT-11:00".into());
+
+    assert_eq!(date1.get_utc_day(), 2);
+    assert_eq!(date2.get_utc_day(), 3);
+}
+
+#[wasm_bindgen_test]
+fn get_utc_full_year() {
+    let date1 = Date::new(&"December 31, 1975, 23:15:30 GMT+11:00".into());
+    let date2 = Date::new(&"December 31, 1975, 23:15:30 GMT-11:00".into());
+    assert_eq!(date1.get_utc_full_year(), 1975);
+    assert_eq!(date2.get_utc_full_year(), 1976);
+}
+
+#[wasm_bindgen_test]
+fn get_utc_hours() {
+    let date1 = Date::new(&"December 31, 1975, 23:15:30 GMT+11:00".into());
+    let date2 = Date::new(&"December 31, 1975, 23:15:30 GMT-11:00".into());
+
+    assert_eq!(date1.get_utc_hours(), 12);
+    assert_eq!(date2.get_utc_hours(), 10);
+}
+
+#[wasm_bindgen_test]
+fn get_utc_milliseconds() {
+    let date = Date::new(&"2018-01-02T03:04:05.678Z".into());
+    assert_eq!(date.get_utc_milliseconds(), 678);
+}
+
+#[wasm_bindgen_test]
+fn get_utc_minutes() {
+    let date1 = Date::new(&"1 January 2000 03:15:30 GMT+07:00".into());
+    let date2 = Date::new(&"1 January 2000 03:15:30 GMT+03:30".into());
+    assert_eq!(date1.get_utc_minutes(), 15);
+    assert_eq!(date2.get_utc_minutes(), 45);
+}
+
+#[wasm_bindgen_test]
+fn get_utc_month() {
+    let date1 = Date::new(&"December 31, 1975, 23:15:30 GMT+11:00".into());
+    let date2 = Date::new(&"December 31, 1975, 23:15:30 GMT-11:00".into());
+
+    assert_eq!(date1.get_utc_month(), 11);
+    assert_eq!(date2.get_utc_month(), 0);
+}
+
+#[wasm_bindgen_test]
+fn get_utc_seconds() {
+    let date = Date::new(&"July 20, 1969, 20:18:04 UTC".into());
+
+    assert_eq!(date.get_utc_seconds(), 4);
+}
+
+#[wasm_bindgen_test]
+fn new() {
+    assert!(JsValue::from(Date::new(&JsValue::undefined())).is_object());
+}
+
+#[wasm_bindgen_test]
+fn new_with_year_month() {
+    let date1 = Date::new_with_year_month(1975, 7);
+
+    assert_eq!(date1.get_full_year(), 1975);
+    assert_eq!(date1.get_month(), 7);
+}
+
+#[wasm_bindgen_test]
+fn new_with_year_month_day() {
+    let date1 = Date::new_with_year_month_day(1975, 7, 8);
+
+    assert_eq!(date1.get_full_year(), 1975);
+    assert_eq!(date1.get_month(), 7);
+    assert_eq!(date1.get_date(), 8);
+}
+
+#[wasm_bindgen_test]
+fn new_with_year_month_day_hr() {
+    let date1 = Date::new_with_year_month_day_hr(1975, 7, 8, 4);
+
+    assert_eq!(date1.get_full_year(), 1975);
+    assert_eq!(date1.get_month(), 7);
+    assert_eq!(date1.get_date(), 8);
+    assert_eq!(date1.get_hours(), 4);
+}
+
+#[wasm_bindgen_test]
+fn new_with_year_month_day_hr_min() {
+    let date1 = Date::new_with_year_month_day_hr_min(1975, 7, 8, 4, 35);
+
+    assert_eq!(date1.get_full_year(), 1975);
+    assert_eq!(date1.get_month(), 7);
+    assert_eq!(date1.get_date(), 8);
+    assert_eq!(date1.get_hours(), 4);
+    assert_eq!(date1.get_minutes(), 35);
+}
+
+#[wasm_bindgen_test]
+fn new_with_year_month_day_hr_min_sec() {
+    let date1 = Date::new_with_year_month_day_hr_min_sec(1975, 7, 8, 4, 35, 25);
+
+    assert_eq!(date1.get_full_year(), 1975);
+    assert_eq!(date1.get_month(), 7);
+    assert_eq!(date1.get_date(), 8);
+    assert_eq!(date1.get_hours(), 4);
+    assert_eq!(date1.get_minutes(), 35);
+    assert_eq!(date1.get_seconds(), 25);
+}
+
+#[wasm_bindgen_test]
+fn new_with_year_month_day_hr_min_sec_milli() {
+    let date1 = Date::new_with_year_month_day_hr_min_sec_milli(1975, 7, 8, 4, 35, 25, 300);
+
+    assert_eq!(date1.get_full_year(), 1975);
+    assert_eq!(date1.get_month(), 7);
+    assert_eq!(date1.get_date(), 8);
+    assert_eq!(date1.get_hours(), 4);
+    assert_eq!(date1.get_minutes(), 35);
+    assert_eq!(date1.get_seconds(), 25);
+    assert_eq!(date1.get_milliseconds(), 300);
+}
+
+#[wasm_bindgen_test]
+fn now() {
+    assert!(Date::now() > 0.);
+}
+
+#[wasm_bindgen_test]
+fn parse() {
+    let date = Date::parse("04 Dec 1995 00:12:00 GMT");
+    let zero = Date::parse("01 Jan 1970 00:00:00 GMT");
+
+    assert_eq!(date, 818035920000.0);
+    assert_eq!(zero, 0.0);
+}
+
+#[wasm_bindgen_test]
+fn set_date() {
+    let event1 = Date::new(&"August 19, 1975 23:15:30".into());
+    let event2 = Date::new(&"August 24, 1975 23:15:30".into());
+
+    let ms = event1.set_date(24);
+
+    assert_eq!(ms, event2.get_time());
+    assert_eq!(event1.get_time(), event2.get_time());
+    assert_eq!(event1.get_date(), 24);
+}
+
+#[wasm_bindgen_test]
+fn set_full_year() {
+    let event1 = Date::new(&"August 19, 1975 23:15:30".into());
+    let event2 = Date::new(&"August 19, 1976 23:15:30".into());
+
+    let ms = event1.set_full_year(1976);
+
+    assert_eq!(ms, event2.get_time());
+    assert_eq!(event1.get_time(), event2.get_time());
+    assert_eq!(event1.get_full_year(), 1976);
+}
+
+#[wasm_bindgen_test]
+fn set_full_year_with_month() {
+    let event1 = Date::new(&"August 19, 1976 23:15:30".into());
+
+    event1.set_full_year_with_month(1979, 4);
+
+    assert_eq!(event1.get_full_year(), 1979);
+    assert_eq!(event1.get_month(), 4);
+}
+
+#[wasm_bindgen_test]
+fn set_full_year_with_month_date() {
+    let event1 = Date::new(&"August 19, 1976 23:15:30".into());
+
+    event1.set_full_year_with_month_date(1979, -1, 25);
+
+    assert_eq!(event1.get_full_year(), 1978);
+    assert_eq!(event1.get_month(), 11);
+    assert_eq!(event1.get_date(), 25);
+}
+
+#[wasm_bindgen_test]
+fn set_hours() {
+    let event1 = Date::new(&"August 19, 1975 23:15:30".into());
+    let event2 = Date::new(&"August 19, 1975 20:15:30".into());
+
+    let ms = event1.set_hours(20);
+
+    assert_eq!(ms, event2.get_time());
+    assert_eq!(event1.get_time(), event2.get_time());
+    assert_eq!(event1.get_hours(), 20);
+}
+
+#[wasm_bindgen_test]
+fn set_milliseconds() {
+    let event = Date::new(&"August 19, 1975 23:15:30".into());
+
+    let ms = event.set_milliseconds(456);
+
+    assert_eq!(ms, event.get_time());
+    assert_eq!(event.get_milliseconds(), 456);
+}
+
+#[wasm_bindgen_test]
+fn set_minutes() {
+    let event1 = Date::new(&"August 19, 1975 23:15:30".into());
+    let event2 = Date::new(&"August 19, 1975 23:45:30".into());
+
+    let ms = event1.set_minutes(45);
+
+    assert_eq!(ms, event2.get_time());
+    assert_eq!(event1.get_time(), event2.get_time());
+    assert_eq!(event1.get_minutes(), 45);
+}
+
+#[wasm_bindgen_test]
+fn set_month() {
+    let event1 = Date::new(&"August 19, 1975 23:15:30".into());
+    let event2 = Date::new(&"April 19, 1975 23:15:30".into());
+
+    let ms = event1.set_month(3);
+
+    assert_eq!(ms, event2.get_time());
+    assert_eq!(event1.get_time(), event2.get_time());
+    assert_eq!(event1.get_month(), 3);
+}
+
+#[wasm_bindgen_test]
+fn set_seconds() {
+    let event1 = Date::new(&"August 19, 1975 23:15:30".into());
+    let event2 = Date::new(&"August 19, 1975 23:15:42".into());
+
+    let ms = event1.set_seconds(42);
+
+    assert_eq!(ms, event2.get_time());
+    assert_eq!(event1.get_time(), event2.get_time());
+    assert_eq!(event1.get_seconds(), 42);
+}
+
+#[wasm_bindgen_test]
+fn set_time() {
+    let event1 = Date::new(&"July 1, 1999".into());
+    let event2 = Date::new(&JsValue::undefined());
+
+    let ms = event2.set_time(event1.get_time());
+
+    assert_eq!(ms, event2.get_time());
+    assert_eq!(event1.get_time(), event2.get_time());
+}
+
+#[wasm_bindgen_test]
+fn set_utc_date() {
+    let event1 = Date::new(&"August 19, 1975 23:15:30 GMT-3:00".into());
+    let event2 = Date::new(&"August 19, 1975 02:15:30 GMT".into());
+
+    let ms = event1.set_utc_date(19);
+
+    assert_eq!(ms, event2.get_time());
+    assert_eq!(event1.get_time(), event2.get_time());
+    assert_eq!(event1.get_utc_date(), 19);
+}
+
+#[wasm_bindgen_test]
+fn set_utc_full_year() {
+    let event1 = Date::new(&"December 31, 1975 23:15:30 GMT-3:00".into());
+    let event2 = Date::new(&"January 01, 1975 02:15:30 GMT".into());
+
+    let ms = event1.set_utc_full_year(1975);
+
+    assert_eq!(ms, event2.get_time());
+    assert_eq!(event1.get_time(), event2.get_time());
+    assert_eq!(event1.get_utc_full_year(), 1975);
+}
+
+#[wasm_bindgen_test]
+fn set_utc_full_year_with_month() {
+    let event1 = Date::new(&"December 31, 1975 23:15:30 GMT-3:00".into());
+
+    event1.set_utc_full_year_with_month(1975, 6);
+
+    assert_eq!(event1.get_utc_full_year(), 1975);
+    assert_eq!(event1.get_utc_month(), 6);
+}
+
+#[wasm_bindgen_test]
+fn set_utc_full_year_with_month_date() {
+    let event1 = Date::new(&"December 31, 1975 23:15:30 GMT-3:00".into());
+
+    event1.set_utc_full_year_with_month_date(1975, -2, 21);
+
+    assert_eq!(event1.get_utc_full_year(), 1974);
+    assert_eq!(event1.get_utc_month(), 10);
+    assert_eq!(event1.get_utc_date(), 21);
+}
+
+#[wasm_bindgen_test]
+fn set_utc_hours() {
+    let event1 = Date::new(&"August 19, 1975 23:15:30 GMT-3:00".into());
+    let event2 = Date::new(&"August 20, 1975 23:15:30 GMT".into());
+
+    let ms = event1.set_utc_hours(23);
+
+    assert_eq!(ms, event2.get_time());
+    assert_eq!(event1.get_time(), event2.get_time());
+    assert_eq!(event1.get_utc_hours(), 23);
+}
+
+#[wasm_bindgen_test]
+fn set_utc_milliseconds() {
+    let event1 = Date::new(&"1995-12-17T09:24:00Z".into());
+    let event2 = Date::new(&"1995-12-17T09:24:00.420Z".into());
+
+    let ms = event1.set_utc_milliseconds(420);
+
+    assert_eq!(ms, event2.get_time());
+    assert_eq!(event1.get_time(), event2.get_time());
+    assert_eq!(event1.get_utc_milliseconds(), 420);
+}
+
+#[wasm_bindgen_test]
+fn set_utc_minutes() {
+    let event1 = Date::new(&"December 31, 1975, 23:15:30 GMT-3:00".into());
+    let event2 = Date::new(&"January 01, 1976 02:25:30 GMT".into());
+
+    let ms = event1.set_utc_minutes(25);
+
+    assert_eq!(ms, event2.get_time());
+    assert_eq!(event1.get_time(), event2.get_time());
+    assert_eq!(event1.get_utc_minutes(), 25);
+}
+
+#[wasm_bindgen_test]
+fn set_utc_month() {
+    let event1 = Date::new(&"December 31, 1975 23:15:30 GMT-3:00".into());
+    let event2 = Date::new(&"December 01, 1976 02:15:30 GMT".into());
+
+    let ms = event1.set_utc_month(11);
+
+    assert_eq!(ms, event2.get_time());
+    assert_eq!(event1.get_time(), event2.get_time());
+    assert_eq!(event1.get_utc_month(), 11);
+}
+
+#[wasm_bindgen_test]
+fn set_utc_seconds() {
+    let event1 = Date::new(&"December 31, 1975 23:15:30 GMT-3:00".into());
+    let event2 = Date::new(&"January 01, 1976 02:15:39 GMT".into());
+
+    let ms = event1.set_utc_seconds(39);
+
+    assert_eq!(ms, event2.get_time());
+    assert_eq!(event1.get_time(), event2.get_time());
+    assert_eq!(event1.get_utc_seconds(), 39);
+}
+
+#[wasm_bindgen_test]
+fn to_date_string() {
+    // Create the date from date components rather than a string because this
+    // constructor interprets it as a date in the local time zone, which is how
+    // `toDateString` outputs it. This makes sure that this test will work in any
+    // time zone.
+    // October is 9 rather than 10 because the months count from 0.
+    let date = Date::new_with_year_month_day_hr_min(2011, 9, 5, 14, 48);
+    assert_eq!(JsValue::from(date.to_date_string()), "Wed Oct 05 2011");
+}
+
+#[wasm_bindgen_test]
+fn to_iso_string() {
+    let date = Date::new(&"05 October 2011 14:48 UTC".into());
+    assert_eq!(
+        JsValue::from(date.to_iso_string()),
+        "2011-10-05T14:48:00.000Z"
+    );
+}
+
+#[wasm_bindgen_test]
+fn to_json() {
+    let date = Date::new(&"August 19, 1975 23:15:30 UTC".into());
+
+    assert_eq!(JsValue::from(date.to_json()), "1975-08-19T23:15:30.000Z");
+}
+
+#[wasm_bindgen_test]
+fn to_locale_date_string() {
+    let date = Date::new(&"August 19, 1975 23:15:30 UTC".into());
+    let s = date.to_locale_date_string("de-DE", &JsValue::undefined());
+    assert!(s.length() > 0);
+}
+
+#[wasm_bindgen_test]
+fn to_locale_string() {
+    let date = Date::new(&"August 19, 1975 23:15:30 UTC".into());
+    let s = date.to_locale_string("de-DE", &JsValue::undefined());
+    assert!(s.length() > 0);
+}
+
+#[wasm_bindgen_test]
+fn to_locale_time_string() {
+    let date = Date::new(&"August 19, 1975 23:15:30".into());
+    assert_eq!(
+        JsValue::from(date.to_locale_time_string("en-US")),
+        "11:15:30 PM",
+    );
+}
+
+#[wasm_bindgen_test]
+fn to_string() {
+    let date = Date::new(&"August 19, 1975 23:15:30".into());
+    let s = JsValue::from(date.to_string()).as_string().unwrap();
+    assert_eq!(&s[0..15], "Tue Aug 19 1975");
+}
+
+#[wasm_bindgen_test]
+fn to_time_string() {
+    let date = Date::new(&"August 19, 1975 23:15:30".into());
+    let s = JsValue::from(date.to_time_string()).as_string().unwrap();
+    assert_eq!(&s[0..8], "23:15:30");
+}
+
+#[wasm_bindgen_test]
+fn to_utc_string() {
+    let date = Date::new(&"14 Jun 2017 00:00:00 PDT".into());
+    let s = JsValue::from(date.to_utc_string()).as_string().unwrap();
+    assert_eq!(s, "Wed, 14 Jun 2017 07:00:00 GMT");
+}
+
+#[wasm_bindgen_test]
+fn utc() {
+    assert_eq!(Date::utc(2018f64, 6f64), 1530403200000.0);
+}
+
+#[wasm_bindgen_test]
+fn value_of() {
+    let date = Date::new(&Date::utc(2018f64, 6f64).into());
+    assert_eq!(date.value_of(), 1530403200000.0);
+}
+
+#[wasm_bindgen_test]
+fn date_inheritance() {
+    let date = Date::new(&"August 19, 1975 23:15:30".into());
+    assert!(date.is_instance_of::<Date>());
+    assert!(date.is_instance_of::<Object>());
+    let _: &Object = date.as_ref();
+}
diff --git a/vendor/js-sys/tests/wasm/Error.rs b/vendor/js-sys/tests/wasm/Error.rs
new file mode 100644
index 000000000..efe6dfcaf
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Error.rs
@@ -0,0 +1,75 @@
+use js_sys::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::JsValue;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen_test]
+fn new() {
+    let error = Error::new("some message");
+    assert_eq!(JsValue::from(error.message()), "some message");
+}
+
+#[wasm_bindgen_test]
+fn new_with_cause() {
+    let options = Object::new();
+    Reflect::set(
+        options.as_ref(),
+        &JsValue::from("cause"),
+        &JsValue::from("some cause"),
+    )
+    .unwrap();
+    let error = Error::new_with_options("some message", &options);
+    assert_eq!(error.cause(), "some cause");
+}
+
+#[wasm_bindgen_test]
+fn empty_cause() {
+    let error = Error::new("test");
+    assert_eq!(error.cause(), JsValue::UNDEFINED);
+}
+
+#[wasm_bindgen_test]
+fn set_cause() {
+    let error = Error::new("test");
+    error.set_cause(&JsValue::from("different"));
+    assert_eq!(error.cause(), "different");
+}
+
+#[wasm_bindgen_test]
+fn set_message() {
+    let error = Error::new("test");
+    error.set_message("another");
+    assert_eq!(JsValue::from(error.message()), "another");
+}
+
+#[wasm_bindgen_test]
+fn name() {
+    let error = Error::new("test");
+    assert_eq!(JsValue::from(error.name()), "Error");
+}
+
+#[wasm_bindgen_test]
+fn set_name() {
+    let error = Error::new("test");
+    error.set_name("different");
+    assert_eq!(JsValue::from(error.name()), "different");
+}
+
+#[wasm_bindgen_test]
+fn to_string() {
+    let error = Error::new("error message 1");
+    assert_eq!(JsValue::from(error.to_string()), "Error: error message 1");
+    error.set_name("error_name_1");
+    assert_eq!(
+        JsValue::from(error.to_string()),
+        "error_name_1: error message 1"
+    );
+}
+
+#[wasm_bindgen_test]
+fn error_inheritance() {
+    let error = Error::new("test");
+    assert!(error.is_instance_of::<Error>());
+    assert!(error.is_instance_of::<Object>());
+    let _: &Object = error.as_ref();
+}
diff --git a/vendor/js-sys/tests/wasm/EvalError.rs b/vendor/js-sys/tests/wasm/EvalError.rs
new file mode 100644
index 000000000..52abe06ca
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/EvalError.rs
@@ -0,0 +1,62 @@
+use js_sys::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::JsValue;
+use wasm_bindgen_test::*;
+
+// Note: This error is not thrown any more, so there are no tests that will generate this error.
+// Instead we just have to manually construct it
+
+#[wasm_bindgen_test]
+fn new() {
+    let error = EvalError::new("some message");
+    let base_error: &Error = error.dyn_ref().unwrap();
+    assert_eq!(JsValue::from(base_error.message()), "some message");
+}
+
+#[wasm_bindgen_test]
+fn set_message() {
+    let error = EvalError::new("test");
+    let base_error: &Error = error.dyn_ref().unwrap();
+    base_error.set_message("another");
+    assert_eq!(JsValue::from(base_error.message()), "another");
+}
+
+#[wasm_bindgen_test]
+fn name() {
+    let error = EvalError::new("test");
+    let base_error: &Error = error.dyn_ref().unwrap();
+    assert_eq!(JsValue::from(base_error.name()), "EvalError");
+}
+
+#[wasm_bindgen_test]
+fn set_name() {
+    let error = EvalError::new("test");
+    let base_error: &Error = error.dyn_ref().unwrap();
+    base_error.set_name("different");
+    assert_eq!(JsValue::from(base_error.name()), "different");
+}
+
+#[wasm_bindgen_test]
+fn to_string() {
+    let error = EvalError::new("error message 1");
+    let base_error: &Error = error.dyn_ref().unwrap();
+    assert_eq!(
+        JsValue::from(base_error.to_string()),
+        "EvalError: error message 1"
+    );
+    base_error.set_name("error_name_1");
+    assert_eq!(
+        JsValue::from(base_error.to_string()),
+        "error_name_1: error message 1"
+    );
+}
+
+#[wasm_bindgen_test]
+fn evalerror_inheritance() {
+    let error = EvalError::new("some message");
+    assert!(error.is_instance_of::<EvalError>());
+    assert!(error.is_instance_of::<Error>());
+    assert!(error.is_instance_of::<Object>());
+    let _: &Error = error.as_ref();
+    let _: &Object = error.as_ref();
+}
diff --git a/vendor/js-sys/tests/wasm/Function.js b/vendor/js-sys/tests/wasm/Function.js
new file mode 100644
index 000000000..14242a63c
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Function.js
@@ -0,0 +1,19 @@
+// Used for `Function.rs` tests
+exports.get_function_to_bind = function() {
+  return function() { return this.x || 1; }
+};
+exports.get_value_to_bind_to = function() {
+  return { x: 2 };
+};
+exports.list = function() {
+  return function() {return Array.prototype.slice.call(arguments);}
+};
+exports.add_arguments = function() {
+    return function(arg1, arg2) {return arg1 + arg2}
+};
+exports.call_function = function(f) {
+  return f();
+};
+exports.call_function_arg =  function(f, arg1) {
+  return f(arg1);
+};
\ No newline at end of file
diff --git a/vendor/js-sys/tests/wasm/Function.rs b/vendor/js-sys/tests/wasm/Function.rs
new file mode 100644
index 000000000..c87a46cca
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Function.rs
@@ -0,0 +1,134 @@
+use js_sys::*;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(js_name = max, js_namespace = Math)]
+    static MAX: Function;
+
+    type ArrayPrototype;
+    #[wasm_bindgen(method, getter, structural)]
+    pub fn push(this: &ArrayPrototype) -> Function;
+    #[wasm_bindgen(js_name = prototype, js_namespace = Array)]
+    static ARRAY_PROTOTYPE2: ArrayPrototype;
+}
+
+#[wasm_bindgen_test]
+fn apply() {
+    let args = Array::new();
+    args.push(&1.into());
+    args.push(&2.into());
+    args.push(&3.into());
+    assert_eq!(MAX.apply(&JsValue::undefined(), &args).unwrap(), 3);
+
+    let arr = JsValue::from(Array::new());
+    let args = Array::new();
+    args.push(&1.into());
+    ARRAY_PROTOTYPE2.push().apply(&arr, &args).unwrap();
+    assert_eq!(Array::from(&arr).length(), 1);
+}
+
+#[wasm_bindgen(module = "tests/wasm/Function.js")]
+extern "C" {
+    fn get_function_to_bind() -> Function;
+    fn get_value_to_bind_to() -> JsValue;
+    fn list() -> Function;
+    fn add_arguments() -> Function;
+    fn call_function(f: &Function) -> JsValue;
+    fn call_function_arg(f: &Function, arg0: JsValue) -> JsValue;
+
+}
+
+#[wasm_bindgen_test]
+fn bind() {
+    let f = get_function_to_bind();
+    let new_f = f.bind(&get_value_to_bind_to());
+    assert_eq!(call_function(&f), 1);
+    assert_eq!(call_function(&new_f), 2);
+}
+
+#[wasm_bindgen_test]
+fn bind0() {
+    let f = get_function_to_bind();
+    let new_f = f.bind0(&get_value_to_bind_to());
+    assert_eq!(call_function(&f), 1);
+    assert_eq!(call_function(&new_f), 2);
+}
+
+#[wasm_bindgen_test]
+fn bind1() {
+    let a_list = list();
+    let prepended_list = a_list.bind1(&JsValue::NULL, &JsValue::from(2));
+
+    assert_eq!(Array::from(&call_function(&prepended_list)).pop(), 2);
+
+    let adder = add_arguments();
+    let add_42 = adder.bind1(&JsValue::NULL, &JsValue::from(42));
+
+    assert_eq!(call_function_arg(&add_42, JsValue::from(1)), 43);
+    assert_eq!(call_function_arg(&add_42, JsValue::from(378)), 420);
+}
+
+#[wasm_bindgen_test]
+fn bind2() {
+    let a_list = list();
+    let prepended_list = a_list.bind2(&JsValue::NULL, &JsValue::from(2), &JsValue::from(3));
+
+    let arr = Array::from(&call_function(&prepended_list));
+
+    assert_eq!(arr.pop(), 3);
+    assert_eq!(arr.pop(), 2);
+
+    let adder = add_arguments();
+    let always_69 = adder.bind2(&JsValue::NULL, &JsValue::from(66), &JsValue::from(3));
+
+    assert_eq!(call_function(&always_69), 69);
+}
+
+#[wasm_bindgen_test]
+fn bind3() {
+    let a_list = list();
+    let prepended_list = a_list.bind3(
+        &JsValue::NULL,
+        &JsValue::from(2),
+        &JsValue::from(3),
+        &JsValue::from(4),
+    );
+
+    let arr = Array::from(&call_function(&prepended_list));
+
+    assert_eq!(arr.pop(), 4);
+    assert_eq!(arr.pop(), 3);
+    assert_eq!(arr.pop(), 2);
+
+    let adder = add_arguments();
+    let always_69 = adder.bind2(&JsValue::NULL, &JsValue::from(66), &JsValue::from(3));
+
+    assert_eq!(call_function(&always_69), 69);
+}
+
+#[wasm_bindgen_test]
+fn length() {
+    assert_eq!(MAX.length(), 2);
+    assert_eq!(ARRAY_PROTOTYPE2.push().length(), 1);
+}
+
+#[wasm_bindgen_test]
+fn name() {
+    assert_eq!(JsValue::from(MAX.name()), "max");
+    assert_eq!(JsValue::from(ARRAY_PROTOTYPE2.push().name()), "push");
+}
+
+#[wasm_bindgen_test]
+fn to_string() {
+    assert!(MAX.to_string().length() > 0);
+}
+
+#[wasm_bindgen_test]
+fn function_inheritance() {
+    assert!(MAX.is_instance_of::<Function>());
+    assert!(MAX.is_instance_of::<Object>());
+    let _: &Object = MAX.as_ref();
+}
diff --git a/vendor/js-sys/tests/wasm/Generator.js b/vendor/js-sys/tests/wasm/Generator.js
new file mode 100644
index 000000000..2cb59cca3
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Generator.js
@@ -0,0 +1,23 @@
+exports.one_two_generator = function() {
+  function* generator() {
+    yield 1;
+    yield 2;
+  }
+  return generator();
+};
+
+exports.dummy_generator = function() {
+  function* generator() {
+    const reply = yield '2 * 2';
+    return reply === 4;
+  }
+  return generator();
+};
+
+exports.broken_generator = function() {
+  function* brokenGenerator() {
+    throw new Error('Something went wrong');
+    yield 1;
+  }
+  return brokenGenerator();
+};
diff --git a/vendor/js-sys/tests/wasm/Generator.rs b/vendor/js-sys/tests/wasm/Generator.rs
new file mode 100644
index 000000000..690bb2260
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Generator.rs
@@ -0,0 +1,66 @@
+use js_sys::*;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen(module = "tests/wasm/Generator.js")]
+extern "C" {
+    fn one_two_generator() -> Generator;
+    fn dummy_generator() -> Generator;
+    fn broken_generator() -> Generator;
+
+    type GeneratorResult;
+
+    #[wasm_bindgen(method, getter, structural)]
+    fn value(this: &GeneratorResult) -> JsValue;
+    #[wasm_bindgen(method, getter, structural)]
+    fn done(this: &GeneratorResult) -> bool;
+
+}
+
+#[wasm_bindgen_test]
+fn return_() {
+    let gen = one_two_generator();
+    gen.next(&JsValue::undefined()).unwrap();
+
+    let res = GeneratorResult::from(gen.return_(&42.into()));
+    assert_eq!(res.value(), 42);
+    assert!(res.done());
+
+    let next = GeneratorResult::from(gen.next(&JsValue::undefined()).unwrap());
+    assert!(next.value().is_undefined());
+    assert!(next.done());
+}
+
+#[wasm_bindgen_test]
+fn next() {
+    let gen = dummy_generator();
+
+    let result = GeneratorResult::from(gen.next(&JsValue::undefined()).unwrap());
+    assert!(!result.done());
+    assert_eq!(result.value(), "2 * 2");
+
+    let result = GeneratorResult::from(gen.next(&4.into()).unwrap());
+    assert!(result.done());
+    assert_eq!(result.value(), true);
+
+    assert!(broken_generator().next(&3.into()).is_err());
+}
+
+#[wasm_bindgen_test]
+fn throw() {
+    let gen = one_two_generator();
+    gen.next(&JsValue::undefined()).unwrap();
+
+    assert!(gen.throw(&Error::new("something went wrong")).is_err());
+    let next = GeneratorResult::from(gen.next(&JsValue::undefined()).unwrap());
+    assert!(next.value().is_undefined());
+    assert!(next.done());
+}
+
+#[wasm_bindgen_test]
+fn generator_inheritance() {
+    let gen = dummy_generator();
+
+    assert!(gen.is_instance_of::<Object>());
+}
diff --git a/vendor/js-sys/tests/wasm/Intl.rs b/vendor/js-sys/tests/wasm/Intl.rs
new file mode 100644
index 000000000..427ea00a5
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Intl.rs
@@ -0,0 +1,124 @@
+use js_sys::*;
+use wasm_bindgen::{JsCast, JsValue};
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen_test]
+fn get_canonical_locales() {
+    let locales = Array::new();
+    locales.push(&"EN-US".into());
+    locales.push(&"Fr".into());
+    let locales = JsValue::from(locales);
+    let canonical_locales = Intl::get_canonical_locales(&locales);
+    assert_eq!(canonical_locales.length(), 2);
+    canonical_locales.for_each(&mut |l, i, _| {
+        if i == 0 {
+            assert_eq!(l, "en-US");
+        } else {
+            assert_eq!(l, "fr");
+        }
+    });
+    let canonical_locales = Intl::get_canonical_locales(&"EN-US".into());
+    assert_eq!(canonical_locales.length(), 1);
+    canonical_locales.for_each(&mut |l, _, _| {
+        assert_eq!(l, "en-US");
+    });
+}
+
+#[wasm_bindgen_test]
+fn collator() {
+    let locales = Array::of1(&JsValue::from("en-US"));
+    let opts = Object::new();
+
+    let c = Intl::Collator::new(&locales, &opts);
+    assert!(c.compare().is_instance_of::<Function>());
+    assert!(c.resolved_options().is_instance_of::<Object>());
+
+    let a = Intl::Collator::supported_locales_of(&locales, &opts);
+    assert!(a.is_instance_of::<Array>());
+}
+
+#[wasm_bindgen_test]
+fn collator_inheritance() {
+    let locales = Array::of1(&JsValue::from("en-US"));
+    let opts = Object::new();
+    let c = Intl::Collator::new(&locales, &opts);
+
+    assert!(c.is_instance_of::<Intl::Collator>());
+    assert!(c.is_instance_of::<Object>());
+    let _: &Object = c.as_ref();
+}
+
+#[wasm_bindgen_test]
+fn date_time_format() {
+    let locales = Array::of1(&JsValue::from("en-US"));
+    let opts = Object::new();
+    let epoch = Date::new(&JsValue::from(0));
+
+    let c = Intl::DateTimeFormat::new(&locales, &opts);
+    assert!(c.format().is_instance_of::<Function>());
+    assert!(c.format_to_parts(&epoch).is_instance_of::<Array>());
+    assert!(c.resolved_options().is_instance_of::<Object>());
+
+    let a = Intl::DateTimeFormat::supported_locales_of(&locales, &opts);
+    assert!(a.is_instance_of::<Array>());
+}
+
+#[wasm_bindgen_test]
+fn date_time_format_inheritance() {
+    let locales = Array::of1(&JsValue::from("en-US"));
+    let opts = Object::new();
+    let c = Intl::DateTimeFormat::new(&locales, &opts);
+
+    assert!(c.is_instance_of::<Intl::DateTimeFormat>());
+    assert!(c.is_instance_of::<Object>());
+    let _: &Object = c.as_ref();
+}
+
+#[wasm_bindgen_test]
+fn number_format() {
+    let locales = Array::of1(&JsValue::from("en-US"));
+    let opts = Object::new();
+
+    let n = Intl::NumberFormat::new(&locales, &opts);
+    assert!(n.format().is_instance_of::<Function>());
+    assert!(n.format_to_parts(42.5).is_instance_of::<Array>());
+    assert!(n.resolved_options().is_instance_of::<Object>());
+
+    let a = Intl::NumberFormat::supported_locales_of(&locales, &opts);
+    assert!(a.is_instance_of::<Array>());
+}
+
+#[wasm_bindgen_test]
+fn number_format_inheritance() {
+    let locales = Array::of1(&JsValue::from("en-US"));
+    let opts = Object::new();
+    let n = Intl::NumberFormat::new(&locales, &opts);
+
+    assert!(n.is_instance_of::<Intl::NumberFormat>());
+    assert!(n.is_instance_of::<Object>());
+    let _: &Object = n.as_ref();
+}
+
+#[wasm_bindgen_test]
+fn plural_rules() {
+    let locales = Array::of1(&JsValue::from("en-US"));
+    let opts = Object::new();
+
+    let r = Intl::PluralRules::new(&locales, &opts);
+    assert!(r.resolved_options().is_instance_of::<Object>());
+    assert_eq!(r.select(1_f64), "one");
+
+    let a = Intl::PluralRules::supported_locales_of(&locales, &opts);
+    assert!(a.is_instance_of::<Array>());
+}
+
+#[wasm_bindgen_test]
+fn plural_rules_inheritance() {
+    let locales = Array::of1(&JsValue::from("en-US"));
+    let opts = Object::new();
+    let r = Intl::PluralRules::new(&locales, &opts);
+
+    assert!(r.is_instance_of::<Intl::PluralRules>());
+    assert!(r.is_instance_of::<Object>());
+    let _: &Object = r.as_ref();
+}
diff --git a/vendor/js-sys/tests/wasm/Iterator.js b/vendor/js-sys/tests/wasm/Iterator.js
new file mode 100644
index 000000000..79b8c5006
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Iterator.js
@@ -0,0 +1,19 @@
+exports.get_iterable = () => ["one", "two", "three"];
+
+exports.get_not_iterable = () => new Object;
+
+exports.get_symbol_iterator_throws = () => ({
+  [Symbol.iterator]: () => { throw new Error("nope"); },
+});
+
+exports.get_symbol_iterator_not_function = () => ({
+  [Symbol.iterator]: 5,
+});
+
+exports.get_symbol_iterator_returns_not_object = () => ({
+  [Symbol.iterator]: () => 5,
+});
+
+exports.get_symbol_iterator_returns_object_without_next = () => ({
+  [Symbol.iterator]: () => new Object,
+});
diff --git a/vendor/js-sys/tests/wasm/Iterator.rs b/vendor/js-sys/tests/wasm/Iterator.rs
new file mode 100644
index 000000000..f06c58b54
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Iterator.rs
@@ -0,0 +1,42 @@
+use js_sys::*;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen(module = "tests/wasm/Iterator.js")]
+extern "C" {
+    fn get_iterable() -> JsValue;
+
+    fn get_not_iterable() -> JsValue;
+
+    fn get_symbol_iterator_throws() -> JsValue;
+
+    fn get_symbol_iterator_not_function() -> JsValue;
+
+    fn get_symbol_iterator_returns_not_object() -> JsValue;
+
+    fn get_symbol_iterator_returns_object_without_next() -> JsValue;
+}
+
+#[wasm_bindgen_test]
+fn try_iter_handles_iteration_protocol() {
+    assert_eq!(
+        try_iter(&get_iterable())
+            .unwrap()
+            .unwrap()
+            .map(|x| x.unwrap().as_string().unwrap())
+            .collect::<Vec<_>>(),
+        vec!["one", "two", "three"]
+    );
+
+    assert!(try_iter(&get_not_iterable()).unwrap().is_none());
+    assert!(try_iter(&get_symbol_iterator_throws()).is_err());
+    assert!(try_iter(&get_symbol_iterator_not_function())
+        .unwrap()
+        .is_none());
+    assert!(try_iter(&get_symbol_iterator_returns_not_object())
+        .unwrap()
+        .is_none());
+    assert!(try_iter(&get_symbol_iterator_returns_object_without_next())
+        .unwrap()
+        .is_none());
+}
diff --git a/vendor/js-sys/tests/wasm/JSON.rs b/vendor/js-sys/tests/wasm/JSON.rs
new file mode 100644
index 000000000..920ac1d6f
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/JSON.rs
@@ -0,0 +1,198 @@
+use js_sys::*;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen_test]
+fn parse_array() {
+    let js_array = JSON::parse("[1, 2, 3]").unwrap();
+    assert!(Array::is_array(&js_array));
+
+    let array = Array::from(&js_array);
+    assert_eq!(array.length(), 3);
+    assert_eq!(array.pop(), 3);
+    assert_eq!(array.pop(), 2);
+    assert_eq!(array.pop(), 1);
+}
+
+#[wasm_bindgen_test]
+fn parse_object() {
+    let js_object = JSON::parse("{\"x\": 5, \"y\": true, \"z\": [\"foo\", \"bar\"]}").unwrap();
+    assert!(js_object.is_object());
+
+    let obj = Object::from(js_object);
+    let keys = Object::keys(&obj);
+    assert_eq!(keys.length(), 3);
+    assert_eq!(keys.pop().as_string().unwrap(), "z");
+    assert_eq!(keys.pop().as_string().unwrap(), "y");
+    assert_eq!(keys.pop().as_string().unwrap(), "x");
+
+    let values = Object::values(&obj);
+    assert_eq!(values.length(), 3);
+
+    let z = values.pop();
+    assert!(Array::is_array(&z));
+    let z_array = Array::from(&z);
+    assert_eq!(z_array.length(), 2);
+
+    let y = values.pop();
+    assert_eq!(y.as_bool(), Some(true));
+
+    let x = values.pop();
+    assert_eq!(x.as_f64().unwrap(), 5.0);
+}
+
+#[wasm_bindgen_test]
+fn parse_error() {
+    let js_object = JSON::parse("invalid json");
+    assert!(js_object.is_err());
+    let err = js_object.unwrap_err();
+    assert!(err.is_instance_of::<Error>());
+}
+
+#[wasm_bindgen_test]
+fn stringify() {
+    let arr = Array::new();
+    arr.push(&JsValue::from(1));
+    arr.push(&JsValue::from(true));
+    arr.push(&JsValue::from("hello"));
+
+    let str1: String = JSON::stringify(&JsValue::from(arr)).unwrap().into();
+    assert_eq!(str1, "[1,true,\"hello\"]");
+
+    let obj = Object::new();
+    Reflect::set(obj.as_ref(), &JsValue::from("foo"), &JsValue::from("bar")).unwrap();
+    let str2: String = JSON::stringify(&JsValue::from(obj)).unwrap().into();
+    assert_eq!(str2, "{\"foo\":\"bar\"}");
+}
+
+#[wasm_bindgen_test]
+fn stringify_error() {
+    let func = Function::new_no_args("throw new Error(\"rust really rocks\")");
+    let obj = Object::new();
+    Reflect::set(obj.as_ref(), &JsValue::from("toJSON"), func.as_ref()).unwrap();
+
+    let result = JSON::stringify(&JsValue::from(obj));
+    assert!(result.is_err());
+    let err_obj = result.unwrap_err();
+    assert!(err_obj.is_instance_of::<Error>());
+    let err: &Error = err_obj.dyn_ref().unwrap();
+    let err_msg: String = From::from(err.message());
+    assert!(err_msg.contains("rust really rocks"));
+}
+
+#[wasm_bindgen_test]
+fn stringify_with_replacer() {
+    let obj = Object::new();
+    Reflect::set(obj.as_ref(), &JsValue::from("foo"), &JsValue::from("bar")).unwrap();
+    Reflect::set(
+        obj.as_ref(),
+        &JsValue::from("hello"),
+        &JsValue::from("world"),
+    )
+    .unwrap();
+
+    let replacer_array = Array::new();
+    replacer_array.push(&JsValue::from("hello"));
+    let output1: String =
+        JSON::stringify_with_replacer(&JsValue::from(obj.clone()), &JsValue::from(replacer_array))
+            .unwrap()
+            .into();
+    assert_eq!(output1, "{\"hello\":\"world\"}");
+
+    let replacer_func =
+        Function::new_with_args("key, value", "return key === 'hello' ? undefined : value");
+    let output2: String =
+        JSON::stringify_with_replacer(&JsValue::from(obj), &JsValue::from(replacer_func))
+            .unwrap()
+            .into();
+    assert_eq!(output2, "{\"foo\":\"bar\"}");
+}
+
+#[wasm_bindgen_test]
+fn stringify_with_replacer_error() {
+    let arr = Array::new();
+    arr.push(&JsValue::from(1));
+    arr.push(&JsValue::from(true));
+    arr.push(&JsValue::from("hello"));
+
+    let replacer = Function::new_no_args("throw new Error(\"rust really rocks\")");
+
+    let result = JSON::stringify_with_replacer(&JsValue::from(arr), &JsValue::from(replacer));
+    assert!(result.is_err());
+    let err_obj = result.unwrap_err();
+    assert!(err_obj.is_instance_of::<Error>());
+    let err: &Error = err_obj.dyn_ref().unwrap();
+    let err_msg: String = From::from(err.message());
+    assert!(err_msg.contains("rust really rocks"));
+}
+
+#[wasm_bindgen_test]
+fn stringify_with_replacer_and_space() {
+    let arr = Array::new();
+    arr.push(&JsValue::from(1));
+    arr.push(&JsValue::from(true));
+    arr.push(&JsValue::from("hello"));
+
+    let output1: String = JSON::stringify_with_replacer_and_space(
+        &JsValue::from(arr),
+        &JsValue::NULL,
+        &JsValue::from(4),
+    )
+    .unwrap()
+    .into();
+    assert_eq!(output1, "[\n    1,\n    true,\n    \"hello\"\n]");
+
+    let obj = Object::new();
+    Reflect::set(obj.as_ref(), &JsValue::from("foo"), &JsValue::from("bar")).unwrap();
+    Reflect::set(
+        obj.as_ref(),
+        &JsValue::from("hello"),
+        &JsValue::from("world"),
+    )
+    .unwrap();
+
+    let replacer_array = Array::new();
+    replacer_array.push(&JsValue::from("hello"));
+    let output2: String = JSON::stringify_with_replacer_and_space(
+        &JsValue::from(obj.clone()),
+        &JsValue::from(replacer_array),
+        &JsValue::from(4),
+    )
+    .unwrap()
+    .into();
+    assert_eq!(output2, "{\n    \"hello\": \"world\"\n}");
+
+    let replacer_func =
+        Function::new_with_args("key, value", "return key === 'hello' ? undefined : value");
+    let output3: String = JSON::stringify_with_replacer_and_space(
+        &JsValue::from(obj),
+        &JsValue::from(replacer_func),
+        &JsValue::from(4),
+    )
+    .unwrap()
+    .into();
+    assert_eq!(output3, "{\n    \"foo\": \"bar\"\n}");
+}
+
+#[wasm_bindgen_test]
+fn stringify_with_replacer_and_space_error() {
+    let arr = Array::new();
+    arr.push(&JsValue::from(1));
+    arr.push(&JsValue::from(true));
+    arr.push(&JsValue::from("hello"));
+
+    let replacer = Function::new_no_args("throw new Error(\"rust really rocks\")");
+
+    let result = JSON::stringify_with_replacer_and_space(
+        &JsValue::from(arr),
+        &JsValue::from(replacer),
+        &JsValue::from(4),
+    );
+    assert!(result.is_err());
+    let err_obj = result.unwrap_err();
+    assert!(err_obj.is_instance_of::<Error>());
+    let err: &Error = err_obj.dyn_ref().unwrap();
+    let err_msg: String = From::from(err.message());
+    assert!(err_msg.contains("rust really rocks"));
+}
diff --git a/vendor/js-sys/tests/wasm/JsString.js b/vendor/js-sys/tests/wasm/JsString.js
new file mode 100644
index 000000000..fbaec7ae8
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/JsString.js
@@ -0,0 +1,7 @@
+exports.new_string_object = () => new String("hi");
+
+exports.get_replacer_function = function() {
+	return function upperToHyphenLower(match, offset, string) {
+		return (offset > 0 ? '-' : '') + match.toLowerCase();
+	};
+};
diff --git a/vendor/js-sys/tests/wasm/JsString.rs b/vendor/js-sys/tests/wasm/JsString.rs
new file mode 100644
index 000000000..33cd53bce
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/JsString.rs
@@ -0,0 +1,612 @@
+use js_sys::*;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::JsValue;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen(module = "tests/wasm/JsString.js")]
+extern "C" {
+    fn new_string_object() -> JsValue;
+    fn get_replacer_function() -> Function;
+}
+
+#[wasm_bindgen_test]
+fn js_string_inheritance() {
+    let string = new_string_object();
+    assert!(string.is_instance_of::<JsString>());
+    assert!(string.is_instance_of::<Object>());
+}
+
+#[wasm_bindgen_test]
+fn length() {
+    fn test(s: &str) {
+        assert_eq!(JsString::from(s).length(), s.len() as u32);
+    }
+    test("Mozilla");
+    test("");
+}
+
+#[wasm_bindgen_test]
+fn char_at() {
+    let s = JsString::from("Brave new world");
+    assert_eq!(JsValue::from(s.char_at(0)), "B");
+    assert_eq!(JsValue::from(s.char_at(999)), "");
+}
+
+#[wasm_bindgen_test]
+fn char_code_at() {
+    let s = "Brave new world";
+    let js = JsString::from(s);
+    for (i, b) in s.char_indices() {
+        assert_eq!(js.char_code_at(i as u32), b as u32 as f64);
+    }
+    assert!(js.char_code_at(s.len() as u32).is_nan());
+}
+
+#[wasm_bindgen_test]
+fn code_point_at() {
+    assert_eq!(JsString::from("ABC").code_point_at(1), b'B');
+    assert!(JsString::from("ABC").code_point_at(42).is_undefined());
+}
+
+#[wasm_bindgen_test]
+fn concat() {
+    // TODO: Implement ability to receive multiple optional arguments
+    let s = JsString::from("Hello ").concat(&"World".into());
+    assert_eq!(JsValue::from(s), "Hello World");
+    let foo = JsString::from("foo");
+    assert_eq!(
+        JsValue::from(foo.concat(&Object::new().into())),
+        "foo[object Object]"
+    );
+    assert_eq!(JsValue::from(foo.concat(&Array::new().into())), "foo");
+    assert_eq!(JsValue::from(foo.concat(&JsValue::null())), "foonull");
+    assert_eq!(JsValue::from(foo.concat(&true.into())), "footrue");
+    assert_eq!(JsValue::from(foo.concat(&1234.into())), "foo1234");
+}
+
+#[wasm_bindgen_test]
+fn ends_with() {
+    let s = "To be, or not to be, that is the question.";
+    let js = JsString::from(s);
+
+    // TODO: remove third parameter once we have optional parameters
+    assert_eq!(js.ends_with("question.", s.len() as i32), true);
+    assert_eq!(js.ends_with("to be", s.len() as i32), false);
+    assert_eq!(js.ends_with("to be", 19), true);
+}
+
+#[wasm_bindgen_test]
+fn from_char_code() {
+    let s = "½+¾=";
+    let codes: Vec<u32> = s.chars().map(|char| char as u32).collect();
+
+    assert_eq!(JsString::from_char_code1(codes[0]), "½");
+    assert_eq!(JsString::from_char_code2(codes[0], codes[1]), "½+");
+    assert_eq!(
+        JsString::from_char_code3(codes[0], codes[1], codes[2]),
+        "½+¾"
+    );
+    assert_eq!(
+        JsString::from_char_code4(codes[0], codes[1], codes[2], codes[3]),
+        "½+¾="
+    );
+
+    let codes_u16: Vec<u16> = codes
+        .into_iter()
+        .map(|code| {
+            assert!(code <= u32::from(u16::max_value()));
+            code as u16
+        })
+        .collect();
+
+    assert_eq!(JsString::from_char_code(&codes_u16), "½+¾=");
+}
+
+#[wasm_bindgen_test]
+fn from_code_point() {
+    let s = "☃★♲你";
+    let codes: Vec<u32> = s.chars().map(|char| char as u32).collect();
+
+    assert_eq!(JsString::from_code_point1(codes[0]).unwrap(), "☃");
+    assert_eq!(
+        JsString::from_code_point2(codes[0], codes[1]).unwrap(),
+        "☃★"
+    );
+    assert_eq!(
+        JsString::from_code_point3(codes[0], codes[1], codes[2]).unwrap(),
+        "☃★♲"
+    );
+    assert_eq!(
+        JsString::from_code_point4(codes[0], codes[1], codes[2], codes[3]).unwrap(),
+        "☃★♲你"
+    );
+    assert_eq!(JsString::from_code_point(&codes).unwrap(), "☃★♲你");
+
+    assert!(!JsString::from_code_point1(0x10FFFF).is_err());
+    assert!(JsString::from_code_point1(0x110000).is_err());
+    assert!(JsString::from_code_point1(u32::max_value()).is_err());
+}
+
+#[wasm_bindgen_test]
+fn includes() {
+    let str = JsString::from("Blue Whale");
+
+    // TODO: remove second parameter once we have optional parameters
+    assert_eq!(str.includes("Blue", 0), true);
+    assert_eq!(str.includes("Blute", 0), false);
+    assert_eq!(str.includes("Whale", 0), true);
+    assert_eq!(str.includes("Whale", 5), true);
+    assert_eq!(str.includes("Whale", 7), false);
+    assert_eq!(str.includes("", 0), true);
+    assert_eq!(str.includes("", 16), true);
+}
+
+#[wasm_bindgen_test]
+fn index_of() {
+    let str = JsString::from("Blue Whale");
+
+    // TODO: remove second parameter once we have optional parameters
+    assert_eq!(str.index_of("Blue", 0), 0);
+    // TODO: remove second parameter once we have optional parameters
+    assert_eq!(str.index_of("Blute", 0), -1);
+    assert_eq!(str.index_of("Whale", 0), 5);
+    assert_eq!(str.index_of("Whale", 5), 5);
+    assert_eq!(str.index_of("Whale", 7), -1);
+    // TODO: remove second parameter once we have optional parameters
+    assert_eq!(str.index_of("", 0), 0);
+    assert_eq!(str.index_of("", 9), 9);
+    assert_eq!(str.index_of("", 10), 10);
+    assert_eq!(str.index_of("", 11), 10);
+}
+
+#[wasm_bindgen_test]
+fn last_index_of() {
+    let js = JsString::from("canal");
+    let len = js.length() as i32;
+
+    // TODO: remove second parameter once we have optional parameters
+    assert_eq!(js.last_index_of("a", len), 3);
+    assert_eq!(js.last_index_of("a", 2), 1);
+    assert_eq!(js.last_index_of("a", 0), -1);
+    // TODO: remove second parameter once we have optional parameters
+    assert_eq!(js.last_index_of("x", len), -1);
+    assert_eq!(js.last_index_of("c", -5), 0);
+    assert_eq!(js.last_index_of("c", 0), 0);
+    // TODO: remove second parameter once we have optional parameters
+    assert_eq!(js.last_index_of("", len), 5);
+    assert_eq!(js.last_index_of("", 2), 2);
+}
+
+#[wasm_bindgen_test]
+fn match_() {
+    let s = "The quick brown fox jumped over the lazy dog. It barked.";
+    let re = RegExp::new("[A-Z]", "g");
+    let result = JsString::from(s).match_(&re);
+    let obj = result.unwrap();
+
+    assert_eq!(Reflect::get(obj.as_ref(), &"0".into()).unwrap(), "T");
+    assert_eq!(Reflect::get(obj.as_ref(), &"1".into()).unwrap(), "I");
+
+    let re = RegExp::new("[A-Z]([a-z]*)", "g");
+    let result = JsString::from(s).match_(&re);
+    let obj = result.unwrap();
+
+    assert_eq!(Reflect::get(obj.as_ref(), &"0".into()).unwrap(), "The");
+    assert_eq!(Reflect::get(obj.as_ref(), &"1".into()).unwrap(), "It");
+
+    let result = JsString::from("foo").match_(&re);
+    assert!(result.is_none());
+
+    let s = "For more information, see Chapter 3.4.5.1";
+    let re = RegExp::new("see (chapter \\d+(\\.\\d)*)", "i");
+    let result = JsString::from(s).match_(&re);
+    let obj = result.unwrap();
+
+    assert_eq!(
+        Reflect::get(obj.as_ref(), &"0".into()).unwrap(),
+        "see Chapter 3.4.5.1"
+    );
+    assert_eq!(
+        Reflect::get(obj.as_ref(), &"1".into()).unwrap(),
+        "Chapter 3.4.5.1"
+    );
+    assert_eq!(Reflect::get(obj.as_ref(), &"2".into()).unwrap(), ".1");
+    assert_eq!(Reflect::get(obj.as_ref(), &"index".into()).unwrap(), 22);
+    assert_eq!(Reflect::get(obj.as_ref(), &"input".into()).unwrap(), s);
+}
+
+#[wasm_bindgen_test]
+fn match_all() {
+    let s = "The quick brown fox jumped over the lazy dog. It barked.";
+    let re = RegExp::new("[A-Z]([a-z]*)", "g");
+    let result: Vec<_> = JsString::from(s)
+        .match_all(&re)
+        .into_iter()
+        .collect::<Result<_, _>>()
+        .unwrap();
+
+    let obj = &result[0];
+    assert_eq!(Reflect::get(obj.as_ref(), &"0".into()).unwrap(), "The");
+    assert_eq!(Reflect::get(obj.as_ref(), &"1".into()).unwrap(), "he");
+
+    let obj = &result[1];
+    assert_eq!(Reflect::get(obj.as_ref(), &"0".into()).unwrap(), "It");
+    assert_eq!(Reflect::get(obj.as_ref(), &"1".into()).unwrap(), "t");
+
+    let result: Vec<_> = JsString::from("foo")
+        .match_all(&re)
+        .into_iter()
+        .collect::<Result<_, _>>()
+        .unwrap();
+    assert_eq!(result.len(), 0);
+
+    let s = "For more information, see Chapter 3.4.5.1. Also see Chapter 3.1.4";
+    let re = RegExp::new("see (chapter \\d+(\\.\\d)*)", "gi");
+    let result: Vec<_> = JsString::from(s)
+        .match_all(&re)
+        .into_iter()
+        .collect::<Result<_, _>>()
+        .unwrap();
+
+    let obj = &result[0];
+    assert_eq!(
+        Reflect::get(obj.as_ref(), &"0".into()).unwrap(),
+        "see Chapter 3.4.5.1"
+    );
+    assert_eq!(
+        Reflect::get(obj.as_ref(), &"1".into()).unwrap(),
+        "Chapter 3.4.5.1"
+    );
+    assert_eq!(Reflect::get(obj.as_ref(), &"2".into()).unwrap(), ".1");
+    assert_eq!(Reflect::get(obj.as_ref(), &"index".into()).unwrap(), 22);
+    assert_eq!(Reflect::get(obj.as_ref(), &"input".into()).unwrap(), s);
+
+    let obj = &result[1];
+    assert_eq!(
+        Reflect::get(obj.as_ref(), &"0".into()).unwrap(),
+        "see Chapter 3.1.4"
+    );
+    assert_eq!(
+        Reflect::get(obj.as_ref(), &"1".into()).unwrap(),
+        "Chapter 3.1.4"
+    );
+    assert_eq!(Reflect::get(obj.as_ref(), &"2".into()).unwrap(), ".4");
+    assert_eq!(Reflect::get(obj.as_ref(), &"index".into()).unwrap(), 48);
+    assert_eq!(Reflect::get(obj.as_ref(), &"input".into()).unwrap(), s);
+}
+
+#[wasm_bindgen_test]
+fn normalize() {
+    let js = JsString::from("\u{1E9B}\u{0323}");
+
+    // TODO: Handle undefined
+    assert_eq!(JsValue::from(js.normalize("NFC")), "\u{1E9B}\u{0323}");
+    assert_eq!(
+        JsValue::from(js.normalize("NFD")),
+        "\u{017F}\u{0323}\u{0307}"
+    );
+    assert_eq!(JsValue::from(js.normalize("NFKC")), "\u{1E69}");
+    assert_eq!(
+        JsValue::from(js.normalize("NFKD")),
+        "\u{0073}\u{0323}\u{0307}"
+    );
+}
+
+#[wasm_bindgen_test]
+fn pad_end() {
+    let js = JsString::from("abc");
+
+    // TODO: remove second parameter once we have optional parameters
+    assert_eq!(JsValue::from(js.pad_end(10, " ")), "abc       ");
+    // TODO: remove second parameter once we have optional parameters
+    assert_eq!(JsValue::from(js.pad_end(10, " ")), "abc       ");
+    assert_eq!(JsValue::from(js.pad_end(10, "foo")), "abcfoofoof");
+    assert_eq!(JsValue::from(js.pad_end(6, "123456")), "abc123");
+    // TODO: remove second parameter once we have optional parameters
+    assert_eq!(JsValue::from(js.pad_end(1, " ")), "abc");
+}
+
+#[wasm_bindgen_test]
+fn pad_start() {
+    let js = JsString::from("abc");
+
+    // TODO: remove second parameter once we have optional parameters
+    assert_eq!(js.pad_start(10, " "), "       abc");
+    assert_eq!(js.pad_start(10, "foo"), "foofoofabc");
+    assert_eq!(js.pad_start(6, "123465"), "123abc");
+    assert_eq!(js.pad_start(8, "0"), "00000abc");
+    // TODO: remove second parameter once we have optional parameters
+    assert_eq!(js.pad_start(1, " "), "abc");
+}
+
+#[wasm_bindgen_test]
+fn repeat() {
+    assert_eq!(JsString::from("test").repeat(3), "testtesttest");
+}
+
+#[wasm_bindgen_test]
+fn replace() {
+    let js = JsString::from(
+        "The quick brown fox jumped over the lazy dog. If the dog reacted, was it really lazy?",
+    );
+    let result = js.replace("dog", "ferret");
+
+    assert_eq!(
+        result,
+        "The quick brown fox jumped over the lazy ferret. If the dog reacted, was it really lazy?"
+    );
+
+    let js = JsString::from("borderTop");
+    let result = js.replace_with_function("T", &get_replacer_function());
+
+    assert_eq!(result, "border-top");
+
+    let js = JsString::from(
+        "The quick brown fox jumped over the lazy dog. If the dog reacted, was it really lazy?",
+    );
+    let re = RegExp::new("dog", "g");
+    let result = js.replace_by_pattern(&re, "ferret");
+
+    assert_eq!(result, "The quick brown fox jumped over the lazy ferret. If the ferret reacted, was it really lazy?");
+
+    let js = JsString::from("borderTop");
+    let re = RegExp::new("[A-Z]", "g");
+    let result = js.replace_by_pattern_with_function(&re, &get_replacer_function());
+
+    assert_eq!(result, "border-top");
+}
+
+#[wasm_bindgen_test]
+fn replace_all() {
+    let js = JsString::from(
+        "The quick brown fox jumped over the lazy dog. If the dog reacted, was it really lazy?",
+    );
+    let result = js.replace_all("dog", "ferret");
+
+    assert_eq!(
+        result,
+        "The quick brown fox jumped over the lazy ferret. If the ferret reacted, was it really lazy?"
+    );
+
+    let js = JsString::from("borderTopTest");
+    let result = js.replace_all_with_function("T", &get_replacer_function());
+
+    assert_eq!(result, "border-top-test");
+
+    let js = JsString::from(
+        "The quick brown fox jumped over the lazy dog. If the dog reacted, was it really lazy?",
+    );
+    let re = RegExp::new("dog", "g");
+    let result = js.replace_all_by_pattern(&re, "ferret");
+
+    assert_eq!(result, "The quick brown fox jumped over the lazy ferret. If the ferret reacted, was it really lazy?");
+
+    let js = JsString::from("borderTopTest");
+    let re = RegExp::new("[A-Z]", "g");
+    let result = js.replace_all_by_pattern_with_function(&re, &get_replacer_function());
+
+    assert_eq!(result, "border-top-test");
+}
+
+#[wasm_bindgen_test]
+fn search() {
+    let js = JsString::from(
+        "The quick brown fox jumped over the lazy dog. If the dog reacted, was it really lazy?",
+    );
+    let re = RegExp::new("[^\\w\\s]", "g");
+
+    assert_eq!(js.search(&re), 44);
+
+    let js = JsString::from("hey JudE");
+    let re1 = RegExp::new("[A-Z]", "g");
+    let re2 = RegExp::new("[.]", "g");
+
+    assert_eq!(js.search(&re1), 4);
+    assert_eq!(js.search(&re2), -1);
+}
+
+#[wasm_bindgen_test]
+fn slice() {
+    let characters = JsString::from("acxn18");
+    assert_eq!(characters.slice(1, 3), "cx");
+}
+
+#[wasm_bindgen_test]
+fn split() {
+    let js = JsString::from("Oh brave new world");
+    let result = js.split(" ");
+
+    let mut v = Vec::with_capacity(result.length() as usize);
+    result.for_each(&mut |x, _, _| v.push(x));
+
+    assert_eq!(v[0], "Oh");
+    assert_eq!(v[1], "brave");
+    assert_eq!(v[2], "new");
+    assert_eq!(v[3], "world");
+
+    let js = JsString::from("Oct,Nov,Dec");
+    let result = js.split(",");
+
+    let mut v = Vec::with_capacity(result.length() as usize);
+    result.for_each(&mut |x, _, _| v.push(x));
+
+    assert_eq!(v[0], "Oct");
+    assert_eq!(v[1], "Nov");
+    assert_eq!(v[2], "Dec");
+
+    let result = js.split_limit(",", 2);
+
+    let mut v = Vec::with_capacity(result.length() as usize);
+    result.for_each(&mut |x, _, _| v.push(x));
+
+    assert_eq!(result.length(), 2);
+    assert_eq!(v[0], "Oct");
+    assert_eq!(v[1], "Nov");
+
+    let js = JsString::from("Oh brave new world");
+    let re = RegExp::new("\\s", "g");
+    let result = js.split_by_pattern(&re);
+
+    let mut v = Vec::with_capacity(result.length() as usize);
+    result.for_each(&mut |x, _, _| v.push(x));
+
+    assert_eq!(v[0], "Oh");
+    assert_eq!(v[1], "brave");
+    assert_eq!(v[2], "new");
+    assert_eq!(v[3], "world");
+
+    let result = js.split_by_pattern_limit(&re, 2);
+
+    let mut v = Vec::with_capacity(result.length() as usize);
+    result.for_each(&mut |x, _, _| v.push(x));
+
+    assert_eq!(result.length(), 2);
+    assert_eq!(v[0], "Oh");
+    assert_eq!(v[1], "brave");
+}
+
+#[wasm_bindgen_test]
+fn starts_with() {
+    let js = JsString::from("To be, or not to be, that is the question.");
+
+    // TODO: remove second parameter for both assertions once we have optional parameters
+    assert!(js.starts_with("To be", 0));
+    assert!(!js.starts_with("not to be", 0));
+    assert!(js.starts_with("not to be", 10));
+}
+
+#[wasm_bindgen_test]
+fn substring() {
+    let js = JsString::from("Mozilla");
+
+    assert_eq!(js.substring(0, 1), "M");
+    assert_eq!(js.substring(1, 0), "M");
+
+    assert_eq!(js.substring(0, 6), "Mozill");
+
+    // TODO: Add test once we have optional parameters
+    // assert_eq!(js.substring(4), "lla");
+    assert_eq!(js.substring(4, 7), "lla");
+    assert_eq!(js.substring(7, 4), "lla");
+
+    assert_eq!(js.substring(0, 7), "Mozilla");
+    assert_eq!(js.substring(0, 10), "Mozilla");
+}
+
+#[wasm_bindgen_test]
+fn substr() {
+    let js = JsString::from("Mozilla");
+
+    assert_eq!(js.substr(0, 1), "M");
+    assert_eq!(js.substr(1, 0), "");
+    assert_eq!(js.substr(-1, 1), "a");
+    assert_eq!(js.substr(1, -1), "");
+    // TODO: Uncomment and test these assertions, once we have support for optional parameters
+    // assert_eq!(js.substr(-3), "lla");
+    // assert_eq!(js.substr(1), "ozilla");
+    assert_eq!(js.substr(-20, 2), "Mo");
+    assert_eq!(js.substr(20, 2), "");
+}
+
+#[wasm_bindgen_test]
+fn to_locale_lower_case() {
+    let js = JsString::from("Mozilla");
+    assert_eq!(js.to_locale_lower_case(None), "mozilla");
+    let s = JsString::from("\u{0130}");
+    assert_eq!(s.to_locale_lower_case(Some("tr".into())), "i");
+    assert_ne!(s.to_locale_lower_case(Some("en-US".into())), "i");
+}
+
+#[wasm_bindgen_test]
+fn to_locale_upper_case() {
+    let js = JsString::from("mozilla");
+    assert_eq!(js.to_locale_upper_case(None), "MOZILLA");
+    let s = JsString::from("i\u{0307}");
+    assert_eq!(s.to_locale_upper_case(Some("lt".into())), "I");
+    assert_ne!(s.to_locale_upper_case(Some("en-US".into())), "I");
+}
+
+#[wasm_bindgen_test]
+fn to_lower_case() {
+    assert_eq!(JsString::from("Mozilla").to_lower_case(), "mozilla");
+}
+
+#[wasm_bindgen_test]
+fn to_string() {
+    assert_eq!(JsString::from("foo").to_string(), "foo");
+}
+
+#[wasm_bindgen_test]
+fn to_upper_case() {
+    assert_eq!(JsString::from("Mozilla").to_upper_case(), "MOZILLA");
+}
+
+#[wasm_bindgen_test]
+fn trim() {
+    assert_eq!(JsString::from("   foo  ").trim(), "foo");
+    // Another example of .trim() removing whitespace from just one side.
+    assert_eq!(JsString::from("foo   ").trim(), "foo");
+}
+
+#[wasm_bindgen_test]
+fn trim_end_and_trim_right() {
+    let greeting = JsString::from("   Hello world!   ");
+    let trimmed = "   Hello world!";
+    assert_eq!(greeting.trim_end(), trimmed);
+    assert_eq!(greeting.trim_right(), trimmed);
+}
+
+#[wasm_bindgen_test]
+fn trim_start_and_trim_left() {
+    let greeting = JsString::from("   Hello world!   ");
+    let trimmed = "Hello world!   ";
+    assert_eq!(greeting.trim_start(), trimmed);
+    assert_eq!(greeting.trim_left(), trimmed);
+}
+
+#[wasm_bindgen_test]
+fn value_of() {
+    let greeting = JsString::from("Hello world!");
+    assert_eq!(greeting.value_of(), "Hello world!");
+}
+
+#[wasm_bindgen_test]
+fn raw() {
+    let call_site = Object::new();
+    let raw = Array::of3(&"foo".into(), &"bar".into(), &"123".into());
+    Reflect::set(&call_site.as_ref(), &"raw".into(), &raw.into()).unwrap();
+    assert_eq!(
+        JsString::raw_2(&call_site, "5", "JavaScript").unwrap(),
+        "foo5barJavaScript123"
+    );
+    let substitutions = Array::of2(&"5".into(), &"JavaScript".into());
+    assert_eq!(
+        JsString::raw(&call_site, &substitutions).unwrap(),
+        "foo5barJavaScript123"
+    );
+    assert!(JsString::raw_0(&JsValue::null().unchecked_into()).is_err());
+}
+
+#[wasm_bindgen_test]
+fn is_valid_utf16() {
+    assert!(JsString::from("a").is_valid_utf16());
+    assert!(JsString::from("").is_valid_utf16());
+    assert!(JsString::from("🥑").is_valid_utf16());
+    assert!(JsString::from("Why hello there this, 🥑, is 🥑 and is 🥑").is_valid_utf16());
+
+    assert!(JsString::from_char_code1(0x00).is_valid_utf16());
+    assert!(!JsString::from_char_code1(0xd800).is_valid_utf16());
+    assert!(!JsString::from_char_code1(0xdc00).is_valid_utf16());
+}
+
+#[wasm_bindgen_test]
+fn as_char() {
+    assert_eq!(JsString::from('a').as_char(), Some('a'));
+    assert_eq!(JsString::from('🥑').as_char(), Some('🥑'));
+    assert_eq!(JsString::from("").as_char(), None);
+    assert_eq!(JsString::from("ab").as_char(), None);
+    assert_eq!(JsString::from_char_code1(0xd800).as_char(), None);
+    assert_eq!(JsString::from_char_code1(0xdc00).as_char(), None);
+    assert_eq!(JsString::from_char_code1(0xdfff).as_char(), None);
+}
diff --git a/vendor/js-sys/tests/wasm/Map.rs b/vendor/js-sys/tests/wasm/Map.rs
new file mode 100644
index 000000000..8223c6e70
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Map.rs
@@ -0,0 +1,97 @@
+use js_sys::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen_test]
+fn clear() {
+    let map = Map::new();
+    map.set(&"foo".into(), &"bar".into());
+    map.set(&"bar".into(), &"baz".into());
+    assert_eq!(map.size(), 2);
+    map.clear();
+    assert_eq!(map.size(), 0);
+    map.clear();
+    assert_eq!(map.size(), 0);
+}
+
+#[wasm_bindgen_test]
+fn delete() {
+    let map = Map::new();
+    map.set(&"foo".into(), &"bar".into());
+    assert_eq!(map.size(), 1);
+    assert_eq!(map.delete(&"foo".into()), true);
+    assert_eq!(map.delete(&"bar".into()), false);
+    assert_eq!(map.size(), 0);
+}
+
+#[wasm_bindgen_test]
+fn for_each() {
+    let map = Map::new();
+    map.set(&1.into(), &true.into());
+    map.set(&2.into(), &false.into());
+    map.set(&3.into(), &"awoo".into());
+    map.set(&4.into(), &100.into());
+    map.set(&5.into(), &Array::new().into());
+    map.set(&6.into(), &Object::new().into());
+
+    let mut res = Vec::new();
+    map.for_each(&mut |value, key| {
+        if value.as_bool().is_some() {
+            res.push((key, value));
+        }
+    });
+
+    assert_eq!(map.size(), 6);
+    assert_eq!(res.len(), 2);
+    assert_eq!(res[0].0, 1);
+    assert_eq!(res[0].1, true);
+    assert_eq!(res[1].0, 2);
+    assert_eq!(res[1].1, false);
+}
+
+#[wasm_bindgen_test]
+fn get() {
+    let map = Map::new();
+    map.set(&"foo".into(), &"bar".into());
+    map.set(&1.into(), &2.into());
+    assert_eq!(map.get(&"foo".into()), "bar");
+    assert_eq!(map.get(&1.into()), 2);
+    assert!(map.get(&2.into()).is_undefined());
+}
+
+#[wasm_bindgen_test]
+fn has() {
+    let map = Map::new();
+    map.set(&"foo".into(), &"bar".into());
+    assert_eq!(map.has(&"foo".into()), true);
+    assert_eq!(map.has(&"bar".into()), false);
+}
+
+#[wasm_bindgen_test]
+fn new() {
+    assert_eq!(Map::new().size(), 0);
+}
+
+#[wasm_bindgen_test]
+fn set() {
+    let map = Map::new();
+    let new = map.set(&"foo".into(), &"bar".into());
+    assert_eq!(map.has(&"foo".into()), true);
+    assert_eq!(new.has(&"foo".into()), true);
+}
+
+#[wasm_bindgen_test]
+fn size() {
+    let map = Map::new();
+    map.set(&"foo".into(), &"bar".into());
+    map.set(&"bar".into(), &"baz".into());
+    assert_eq!(map.size(), 2);
+}
+
+#[wasm_bindgen_test]
+fn map_inheritance() {
+    let map = Map::new();
+    assert!(map.is_instance_of::<Map>());
+    assert!(map.is_instance_of::<Object>());
+    let _: &Object = map.as_ref();
+}
diff --git a/vendor/js-sys/tests/wasm/MapIterator.rs b/vendor/js-sys/tests/wasm/MapIterator.rs
new file mode 100644
index 000000000..6a6eec391
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/MapIterator.rs
@@ -0,0 +1,52 @@
+use js_sys::*;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen_test]
+fn entries() {
+    let map = Map::new();
+    map.set(&"uno".into(), &1.into());
+
+    let entries = map.entries();
+
+    let next = entries.next().unwrap();
+    assert_eq!(next.done(), false);
+    assert!(next.value().is_object());
+    assert_eq!(Reflect::get(&next.value(), &0.into()).unwrap(), "uno");
+    assert_eq!(Reflect::get(&next.value(), &1.into()).unwrap(), 1);
+
+    let next = entries.next().unwrap();
+    assert!(next.done());
+    assert!(next.value().is_undefined());
+}
+
+#[wasm_bindgen_test]
+fn keys() {
+    let map = Map::new();
+    map.set(&"uno".into(), &1.into());
+
+    let keys = map.keys();
+
+    let next = keys.next().unwrap();
+    assert_eq!(next.done(), false);
+    assert_eq!(next.value(), "uno");
+
+    let next = keys.next().unwrap();
+    assert!(next.done());
+    assert!(next.value().is_undefined());
+}
+
+#[wasm_bindgen_test]
+fn values() {
+    let map = Map::new();
+    map.set(&"uno".into(), &1.into());
+
+    let values = map.values();
+
+    let next = values.next().unwrap();
+    assert_eq!(next.done(), false);
+    assert_eq!(next.value(), 1);
+
+    let next = values.next().unwrap();
+    assert!(next.done());
+    assert!(next.value().is_undefined());
+}
diff --git a/vendor/js-sys/tests/wasm/Math.rs b/vendor/js-sys/tests/wasm/Math.rs
new file mode 100644
index 000000000..95b70b5c0
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Math.rs
@@ -0,0 +1,271 @@
+use std::f64::consts::PI;
+use std::f64::{NAN, NEG_INFINITY};
+
+use js_sys::*;
+use wasm_bindgen_test::*;
+
+macro_rules! assert_eq {
+    ($a:expr, $b:expr) => {{
+        let (a, b) = (&$a, &$b);
+        if f64::is_infinite(*a) && f64::is_infinite(*b) {
+            assert!(a == b);
+        } else {
+            assert!(
+                (*a - *b).abs() < 1.0e-6,
+                "not approximately equal {:?} ?= {:?}",
+                a,
+                b
+            );
+        }
+    }};
+}
+
+#[wasm_bindgen_test]
+fn abs() {
+    assert_eq!(Math::abs(-32.), 32.);
+    assert_eq!(Math::abs(-32.), 32.);
+    assert_eq!(Math::abs(-4.7), 4.7);
+}
+
+#[wasm_bindgen_test]
+fn acos() {
+    assert_eq!(Math::acos(-1.), PI);
+    assert_eq!(Math::acos(0.5), 1.0471975511965979);
+    assert!(Math::acos(2.).is_nan());
+}
+
+#[wasm_bindgen_test]
+fn acosh() {
+    assert_eq!(Math::acosh(1.), 0.);
+    assert_eq!(Math::acosh(2.), 2.0f64.acosh());
+    assert!(Math::acosh(0.5).is_nan());
+}
+
+#[wasm_bindgen_test]
+fn asin() {
+    assert_eq!(Math::asin(1.), 1.0f64.asin());
+    assert_eq!(Math::asin(0.5), 0.5f64.asin());
+    assert!(Math::asin(2.).is_nan());
+}
+
+#[wasm_bindgen_test]
+fn asinh() {
+    assert_eq!(Math::asinh(1.0), 1f64.asinh());
+    assert_eq!(Math::asinh(0.5), 0.5f64.asinh());
+}
+
+#[wasm_bindgen_test]
+fn atan() {
+    assert_eq!(Math::atan(1.0), 1f64.atan());
+    assert_eq!(Math::atan(0.5), 0.5f64.atan());
+}
+
+#[wasm_bindgen_test]
+fn atan2() {
+    assert_eq!(Math::atan2(1.0, 2.0), 1f64.atan2(2.));
+    assert_eq!(Math::atan2(0.7, 3.8), 0.7f64.atan2(3.8f64));
+}
+
+#[wasm_bindgen_test]
+fn atanh() {
+    assert_eq!(Math::atanh(1.), 1f64.atanh());
+    assert_eq!(Math::atanh(0.5), 0.5f64.atanh());
+    assert!(Math::atanh(2.).is_nan());
+}
+
+#[wasm_bindgen_test]
+fn cbrt() {
+    assert_eq!(Math::cbrt(27.), 3.);
+    assert_eq!(Math::cbrt(12.3), 12.3f64.cbrt());
+}
+
+#[wasm_bindgen_test]
+fn ceil() {
+    assert_eq!(Math::ceil(1.1), 2.);
+    assert_eq!(Math::ceil(-1.1), -1.);
+}
+
+#[wasm_bindgen_test]
+fn clz32() {
+    assert!(Math::clz32(1) == 31);
+    assert!(Math::clz32(1000) == 22);
+}
+
+#[wasm_bindgen_test]
+fn cos() {
+    assert_eq!(Math::cos(0.0), 1.);
+    assert_eq!(Math::cos(1.5), 1.5f64.cos());
+}
+
+#[wasm_bindgen_test]
+fn cosh() {
+    assert_eq!(Math::cosh(0.), 1.);
+    assert_eq!(Math::cosh(2.), 3.7621956910836314);
+}
+
+#[wasm_bindgen_test]
+fn exp() {
+    assert_eq!(Math::exp(0.), 1.);
+    assert_eq!(Math::exp(-1.), 0.36787944117144233);
+    assert_eq!(Math::exp(2.), 7.38905609893065);
+}
+
+#[wasm_bindgen_test]
+fn expm1() {
+    assert_eq!(Math::expm1(0.), 0.);
+    assert_eq!(Math::expm1(1.), 1.718281828459045);
+    assert_eq!(Math::expm1(-1.), -0.6321205588285577);
+    assert_eq!(Math::expm1(2.), 6.38905609893065);
+}
+
+#[wasm_bindgen_test]
+fn floor() {
+    assert_eq!(Math::floor(5.95), 5.);
+    assert_eq!(Math::floor(-5.05), -6.);
+}
+
+#[wasm_bindgen_test]
+fn fround() {
+    assert!(Math::fround(5.5) == 5.5);
+    assert!(Math::fround(5.05) == 5.050000190734863);
+    assert!(Math::fround(5.) == 5.);
+    assert!(Math::fround(-5.05) == -5.050000190734863);
+}
+
+#[wasm_bindgen_test]
+fn hypot() {
+    assert!(Math::hypot(3., 4.) == 5.);
+    assert!(Math::hypot(3.9, 5.2) == 6.5);
+    assert!(Math::hypot(6., 8.) == 10.);
+    assert!(Math::hypot(7., 24.) == 25.);
+}
+
+#[wasm_bindgen_test]
+fn imul() {
+    assert!(Math::imul(3, 4) == 12);
+    assert!(Math::imul(-5, 12) == -60);
+    assert!(Math::imul(0xffffffffu32 as i32, 5) == 0xffffffffu32.wrapping_mul(5) as i32);
+}
+
+#[wasm_bindgen_test]
+fn log() {
+    assert_eq!(Math::log(8.) / Math::log(2.), 3.);
+    assert_eq!(Math::log(625.) / Math::log(5.), 4.);
+}
+
+#[wasm_bindgen_test]
+fn log10() {
+    assert_eq!(Math::log10(100000.), 5.);
+    assert_eq!(Math::log10(1.), 0.);
+    assert_eq!(Math::log10(2.), 0.3010299956639812);
+}
+
+#[wasm_bindgen_test]
+fn log1p() {
+    assert_eq!(Math::log1p(1.), 0.6931471805599453);
+    assert_eq!(Math::log1p(0.), 0.);
+    assert_eq!(Math::log1p(-1.), NEG_INFINITY);
+    assert!(Math::log1p(-2.).is_nan());
+}
+
+#[wasm_bindgen_test]
+fn log2() {
+    assert_eq!(Math::log2(3.), 1.584962500721156);
+    assert_eq!(Math::log2(2.), 1.);
+    assert_eq!(Math::log2(1.), 0.);
+    assert_eq!(Math::log2(0.), NEG_INFINITY);
+}
+
+#[wasm_bindgen_test]
+fn max() {
+    assert_eq!(Math::max(3., 1.), 3.);
+    assert_eq!(Math::max(-3., 1.), 1.);
+    assert_eq!(Math::max(9913., 43.4), 9913.);
+    assert_eq!(Math::max(-27., -43.), -27.);
+    assert_eq!(Math::max(-423.27, -43.1), -43.1);
+}
+
+#[wasm_bindgen_test]
+fn min() {
+    assert_eq!(Math::min(3., 1.), 1.);
+    assert_eq!(Math::min(-3., 1.), -3.);
+    assert_eq!(Math::min(9913., 43.4), 43.4);
+    assert_eq!(Math::min(-27., -43.), -43.);
+    assert_eq!(Math::min(-423.27, -43.1), -423.27);
+}
+
+#[wasm_bindgen_test]
+fn pow() {
+    assert_eq!(Math::pow(7., 2.), 49.);
+    assert_eq!(Math::pow(3.8, 0.5), 3.8f64.powf(0.5f64));
+    assert!(Math::pow(-2., 0.5).is_nan());
+}
+
+#[wasm_bindgen_test]
+fn random() {
+    assert!(Math::random() < 1.);
+    assert!(Math::random() >= 0.);
+}
+
+#[wasm_bindgen_test]
+fn round() {
+    assert_eq!(Math::round(20.49), 20.);
+    assert_eq!(Math::round(20.5), 21.);
+    assert_eq!(Math::round(42.), 42.);
+    assert_eq!(Math::round(-20.5), -20.);
+    assert_eq!(Math::round(-20.51), -21.);
+}
+
+#[wasm_bindgen_test]
+fn sign() {
+    assert_eq!(Math::sign(3.), 1.);
+    assert_eq!(Math::sign(-3.), -1.);
+    assert_eq!(Math::sign(2.3), 1.);
+    assert_eq!(Math::sign(0.), 0.);
+    assert!(Math::sign(NAN).is_nan());
+}
+
+#[wasm_bindgen_test]
+fn sin() {
+    assert_eq!(Math::sin(0.), 0.);
+    assert_eq!(Math::sin(1.), 1f64.sin());
+    assert_eq!(Math::sin(PI / 2.), 1.);
+}
+
+#[wasm_bindgen_test]
+fn sinh() {
+    assert_eq!(Math::sinh(0.), 0.);
+    assert_eq!(Math::sinh(1.), 1f64.sinh());
+    assert_eq!(Math::sinh(2.3), 2.3f64.sinh());
+}
+
+#[wasm_bindgen_test]
+fn sqrt() {
+    assert_eq!(Math::sqrt(9.), 3.);
+    assert_eq!(Math::sqrt(2.), 2f64.sqrt());
+    assert_eq!(Math::sqrt(42.42), 42.42f64.sqrt());
+    assert_eq!(Math::sqrt(1.), 1.);
+    assert!(Math::sqrt(-1.).is_nan());
+}
+
+#[wasm_bindgen_test]
+fn tan() {
+    assert_eq!(Math::tan(0.), 0.);
+    assert_eq!(Math::tan(1.), 1f64.tan());
+    assert_eq!(Math::tan(0.5), 0.5f64.tan());
+}
+
+#[wasm_bindgen_test]
+fn tanh() {
+    assert_eq!(Math::tanh(0.), 0.);
+    assert_eq!(Math::tanh(1.), 1f64.tanh());
+    assert_eq!(Math::tanh(0.5), 0.5f64.tanh());
+}
+
+#[wasm_bindgen_test]
+fn trunc() {
+    assert_eq!(Math::trunc(13.37), 13.);
+    assert_eq!(Math::trunc(42.84), 42.);
+    assert_eq!(Math::trunc(0.123), 0.);
+    assert_eq!(Math::trunc(-0.123), 0.);
+}
diff --git a/vendor/js-sys/tests/wasm/Number.js b/vendor/js-sys/tests/wasm/Number.js
new file mode 100644
index 000000000..c3258885a
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Number.js
@@ -0,0 +1,22 @@
+
+exports.const_epsilon = function() {
+    return Number.EPSILON;
+};
+exports.const_max_safe_integer = function() {
+    return Number.MAX_SAFE_INTEGER;
+};
+exports.const_max_value = function() {
+    return Number.MAX_VALUE;
+};
+exports.const_min_safe_integer = function() {
+    return Number.MIN_SAFE_INTEGER;
+};
+exports.const_min_value = function() {
+    return Number.MIN_VALUE;
+};
+exports.const_negative_infinity = function() {
+    return Number.NEGATIVE_INFINITY;
+};
+exports.const_positive_infinity = function() {
+    return Number.POSITIVE_INFINITY;
+};
diff --git a/vendor/js-sys/tests/wasm/Number.rs b/vendor/js-sys/tests/wasm/Number.rs
new file mode 100644
index 000000000..6c3416eda
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Number.rs
@@ -0,0 +1,158 @@
+use std::f64::{INFINITY, NAN};
+
+use js_sys::*;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen(module = "tests/wasm/Number.js")]
+extern "C" {
+    fn const_epsilon() -> f64;
+    fn const_max_safe_integer() -> f64;
+    fn const_max_value() -> f64;
+    fn const_min_safe_integer() -> f64;
+    fn const_min_value() -> f64;
+    fn const_negative_infinity() -> f64;
+    fn const_positive_infinity() -> f64;
+}
+
+#[wasm_bindgen_test]
+fn is_finite() {
+    assert!(Number::is_finite(&42.into()));
+    assert!(Number::is_finite(&42.1.into()));
+    assert!(!Number::is_finite(&"42".into()));
+    assert!(!Number::is_finite(&NAN.into()));
+    assert!(!Number::is_finite(&INFINITY.into()));
+}
+
+#[wasm_bindgen_test]
+fn is_integer() {
+    assert!(Number::is_integer(&42.into()));
+    assert!(!Number::is_integer(&42.1.into()));
+}
+
+#[wasm_bindgen_test]
+fn is_nan() {
+    assert!(Number::is_nan(&NAN.into()));
+
+    assert!(!Number::is_nan(&JsValue::TRUE));
+    assert!(!Number::is_nan(&JsValue::NULL));
+    assert!(!Number::is_nan(&37.into()));
+    assert!(!Number::is_nan(&"37".into()));
+    assert!(!Number::is_nan(&"37.37".into()));
+    assert!(!Number::is_nan(&"".into()));
+    assert!(!Number::is_nan(&" ".into()));
+
+    // These would all return true with the global isNaN()
+    assert!(!Number::is_nan(&"NaN".into()));
+    assert!(!Number::is_nan(&JsValue::UNDEFINED));
+    assert!(!Number::is_nan(&"blabla".into()));
+}
+
+#[wasm_bindgen_test]
+fn is_safe_integer() {
+    assert_eq!(Number::is_safe_integer(&42.into()), true);
+    assert_eq!(
+        Number::is_safe_integer(&(Math::pow(2., 53.) - 1.).into()),
+        true
+    );
+    assert_eq!(Number::is_safe_integer(&Math::pow(2., 53.).into()), false);
+    assert_eq!(Number::is_safe_integer(&"42".into()), false);
+    assert_eq!(Number::is_safe_integer(&42.1.into()), false);
+    assert_eq!(Number::is_safe_integer(&NAN.into()), false);
+    assert_eq!(Number::is_safe_integer(&INFINITY.into()), false);
+}
+
+#[allow(deprecated)]
+#[wasm_bindgen_test]
+fn new() {
+    let n = Number::new(&JsValue::from(42));
+    let v = JsValue::from(n);
+    assert!(v.is_object());
+    assert_eq!(Number::from(v).value_of(), 42.);
+}
+
+#[wasm_bindgen_test]
+fn parse_int_float() {
+    assert_eq!(Number::parse_int("42", 10), 42.);
+    assert_eq!(Number::parse_int("42", 16), 66.); // 0x42 == 66
+    assert!(Number::parse_int("invalid int", 10).is_nan());
+
+    assert_eq!(Number::parse_float("123456.789"), 123456.789);
+    assert!(Number::parse_float("invalid float").is_nan());
+}
+
+#[wasm_bindgen_test]
+fn to_locale_string() {
+    let number = Number::from(1234.45);
+    assert_eq!(number.to_locale_string("en-US"), "1,234.45");
+    // TODO: these tests seems to be system dependent, disable for now
+    // assert_eq!(wasm.to_locale_string(number, "de-DE"), "1,234.45");
+    // assert_eq!(wasm.to_locale_string(number, "zh-Hans-CN-u-nu-hanidec"), "1,234.45");
+}
+
+#[wasm_bindgen_test]
+fn to_precision() {
+    assert_eq!(Number::from(0.1).to_precision(3).unwrap(), "0.100");
+    assert!(Number::from(10).to_precision(101).is_err());
+}
+
+#[wasm_bindgen_test]
+fn to_string() {
+    assert_eq!(Number::from(42).to_string(10).unwrap(), "42");
+    assert_eq!(Number::from(233).to_string(16).unwrap(), "e9");
+    assert!(Number::from(100).to_string(100).is_err());
+}
+
+#[wasm_bindgen_test]
+fn value_of() {
+    assert_eq!(Number::from(42).value_of(), 42.);
+}
+
+#[wasm_bindgen_test]
+fn to_fixed() {
+    assert_eq!(Number::from(123.456).to_fixed(2).unwrap(), "123.46");
+    assert!(Number::from(10).to_fixed(101).is_err());
+}
+
+#[wasm_bindgen_test]
+fn to_exponential() {
+    assert_eq!(Number::from(123456).to_exponential(2).unwrap(), "1.23e+5");
+    assert!(Number::from(10).to_exponential(101).is_err());
+}
+
+#[allow(deprecated)]
+#[wasm_bindgen_test]
+fn number_inheritance() {
+    let n = Number::new(&JsValue::from(42));
+    assert!(n.is_instance_of::<Number>());
+    assert!(n.is_instance_of::<Object>());
+    let _: &Object = n.as_ref();
+}
+
+#[wasm_bindgen_test]
+fn consts() {
+    assert_eq!(const_epsilon(), Number::EPSILON, "EPSILON");
+    assert_eq!(
+        const_max_safe_integer(),
+        Number::MAX_SAFE_INTEGER,
+        "MAX_SAFE_INTEGER"
+    );
+    assert_eq!(const_max_value(), Number::MAX_VALUE, "MAX_VALUE");
+    assert_eq!(
+        const_min_safe_integer(),
+        Number::MIN_SAFE_INTEGER,
+        "MIN_SAFE_INTEGER"
+    );
+    assert_eq!(const_min_value(), Number::MIN_VALUE, "MIN_VALUE");
+    assert_eq!(
+        const_negative_infinity(),
+        Number::NEGATIVE_INFINITY,
+        "NEGATIVE_INFINITY"
+    );
+    assert_eq!(
+        const_positive_infinity(),
+        Number::POSITIVE_INFINITY,
+        "POSITIVE_INFINITY"
+    );
+}
diff --git a/vendor/js-sys/tests/wasm/Object.js b/vendor/js-sys/tests/wasm/Object.js
new file mode 100644
index 000000000..3f82fc9b7
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Object.js
@@ -0,0 +1,11 @@
+const symbol_key = Symbol();
+
+exports.map_with_symbol_key = function() {
+  return { [symbol_key]: 42 };
+};
+exports.symbol_key = function() {
+  return symbol_key;
+};
+
+exports.Foo = class {};
+exports.Bar = class {};
diff --git a/vendor/js-sys/tests/wasm/Object.rs b/vendor/js-sys/tests/wasm/Object.rs
new file mode 100644
index 000000000..4f1ade972
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Object.rs
@@ -0,0 +1,304 @@
+use js_sys::*;
+use std::f64::NAN;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen]
+extern "C" {
+    type Foo42;
+    #[wasm_bindgen(method, setter, structural)]
+    fn set_foo(this: &Foo42, val: JsValue);
+
+    #[wasm_bindgen(js_name = prototype, js_namespace = Object)]
+    static OBJECT_PROTOTYPE: JsValue;
+    #[wasm_bindgen(js_name = prototype, js_namespace = Array)]
+    static ARRAY_PROTOTYPE: JsValue;
+
+    type DefinePropertyAttrs;
+    #[wasm_bindgen(method, setter, structural)]
+    fn set_value(this: &DefinePropertyAttrs, val: &JsValue);
+
+    type PropertyDescriptor;
+    #[wasm_bindgen(method, getter, structural)]
+    fn value(this: &PropertyDescriptor) -> JsValue;
+}
+
+#[wasm_bindgen(module = "tests/wasm/Object.js")]
+extern "C" {
+    fn map_with_symbol_key() -> Object;
+    fn symbol_key() -> JsValue;
+
+    type Foo;
+    #[wasm_bindgen(constructor)]
+    fn new() -> Foo;
+
+    #[wasm_bindgen(js_name = prototype, js_namespace = Foo)]
+    static FOO_PROTOTYPE: Object;
+    #[wasm_bindgen(js_name = prototype, js_namespace = Bar)]
+    static BAR_PROTOTYPE: Object;
+}
+
+fn foo_42() -> Object {
+    let foo = Foo42::from(JsValue::from(Object::new()));
+    foo.set_foo(42.into());
+    JsValue::from(foo).into()
+}
+
+#[wasm_bindgen_test]
+fn new() {
+    assert!(JsValue::from(Object::new()).is_object());
+}
+
+#[wasm_bindgen_test]
+fn assign() {
+    let a = JsValue::from("a");
+    let b = JsValue::from("b");
+    let c = JsValue::from("c");
+
+    let target = Object::new();
+    Reflect::set(target.as_ref(), a.as_ref(), a.as_ref()).unwrap();
+
+    let src1 = Object::new();
+    Reflect::set(src1.as_ref(), &a, &c).unwrap();
+
+    let src2 = Object::new();
+    Reflect::set(src2.as_ref(), &b, &b).unwrap();
+
+    let src3 = Object::new();
+    Reflect::set(src3.as_ref(), &c, &c).unwrap();
+
+    let res = Object::assign3(&target, &src1, &src2, &src3);
+
+    assert!(Object::is(target.as_ref(), res.as_ref()));
+    assert_eq!(Reflect::get(target.as_ref(), &a).unwrap(), c);
+    assert_eq!(Reflect::get(target.as_ref(), &b).unwrap(), b);
+    assert_eq!(Reflect::get(target.as_ref(), &c).unwrap(), c);
+}
+
+#[wasm_bindgen_test]
+fn create() {
+    let array_proto = eval("Array.prototype")
+        .unwrap()
+        .dyn_into::<Object>()
+        .unwrap();
+    let my_array = Object::create(&array_proto);
+    assert!(my_array.is_instance_of::<Array>());
+}
+
+#[wasm_bindgen_test]
+fn define_property() {
+    let value = DefinePropertyAttrs::from(JsValue::from(Object::new()));
+    value.set_value(&43.into());
+    let descriptor = Object::from(JsValue::from(value));
+    let foo = foo_42();
+    let foo = Object::define_property(&foo, &"bar".into(), &descriptor);
+    assert!(foo.has_own_property(&"bar".into()));
+}
+
+#[wasm_bindgen_test]
+fn define_properties() {
+    let props = Object::new();
+    let descriptor = DefinePropertyAttrs::from(JsValue::from(Object::new()));
+    descriptor.set_value(&42.into());
+    let descriptor = JsValue::from(descriptor);
+    Reflect::set(props.as_ref(), &JsValue::from("bar"), &descriptor).unwrap();
+    Reflect::set(props.as_ref(), &JsValue::from("car"), &descriptor).unwrap();
+    let foo = foo_42();
+    let foo = Object::define_properties(&foo, &props);
+    assert!(foo.has_own_property(&"bar".into()));
+    assert!(foo.has_own_property(&"car".into()));
+}
+
+#[wasm_bindgen_test]
+fn entries() {
+    let entries = Object::entries(&foo_42());
+    assert_eq!(entries.length(), 1);
+    entries.for_each(&mut |x, _, _| {
+        assert!(x.is_object());
+        let array: Array = x.into();
+        assert_eq!(array.shift(), "foo");
+        assert_eq!(array.shift(), 42);
+        assert_eq!(array.length(), 0);
+    });
+}
+
+#[wasm_bindgen_test]
+fn from_entries() {
+    let array = Array::new();
+    let entry_one = Array::new();
+    let entry_two = Array::new();
+    entry_one.push(&"foo".into());
+    entry_one.push(&"bar".into());
+    entry_two.push(&"baz".into());
+    entry_two.push(&42.into());
+    array.push(&entry_one);
+    array.push(&entry_two);
+    let object = Object::from_entries(&array).unwrap();
+
+    assert_eq!(Reflect::get(object.as_ref(), &"foo".into()).unwrap(), "bar");
+    assert_eq!(Reflect::get(object.as_ref(), &"baz".into()).unwrap(), 42);
+
+    let not_iterable = Object::new();
+    let error = Object::from_entries(&not_iterable).unwrap_err();
+    assert!(error.is_instance_of::<TypeError>());
+}
+
+#[wasm_bindgen_test]
+fn get_own_property_descriptor() {
+    let foo = foo_42();
+    let desc = Object::get_own_property_descriptor(&foo, &"foo".into());
+    assert_eq!(PropertyDescriptor::from(desc).value(), 42);
+    let desc = Object::get_own_property_descriptor(&foo, &"bar".into());
+    assert!(desc.is_undefined());
+}
+
+#[wasm_bindgen_test]
+fn get_own_property_descriptors() {
+    let foo = foo_42();
+    let descriptors = Object::get_own_property_descriptors(&foo);
+    let foo_desc = Reflect::get(&descriptors, &"foo".into()).unwrap();
+    assert_eq!(PropertyDescriptor::from(foo_desc).value(), 42);
+}
+
+#[wasm_bindgen_test]
+fn get_own_property_names() {
+    let names = Object::get_own_property_names(&foo_42());
+    assert_eq!(names.length(), 1);
+    names.for_each(&mut |x, _, _| {
+        assert_eq!(x, "foo");
+    });
+}
+
+#[wasm_bindgen_test]
+fn get_own_property_symbols() {
+    let symbols = Object::get_own_property_symbols(&map_with_symbol_key());
+    assert_eq!(symbols.length(), 1);
+}
+
+#[wasm_bindgen_test]
+fn get_prototype_of() {
+    let proto = JsValue::from(Object::get_prototype_of(&Object::new().into()));
+    assert_eq!(proto, *OBJECT_PROTOTYPE);
+    let proto = JsValue::from(Object::get_prototype_of(&Array::new().into()));
+    assert_eq!(proto, *ARRAY_PROTOTYPE);
+}
+
+#[wasm_bindgen_test]
+fn has_own_property() {
+    assert!(foo_42().has_own_property(&"foo".into()));
+    assert!(!foo_42().has_own_property(&"bar".into()));
+    assert!(map_with_symbol_key().has_own_property(&symbol_key()));
+}
+
+#[wasm_bindgen_test]
+fn has_own() {
+    assert!(Object::has_own(&foo_42(), &"foo".into()));
+    assert!(!Object::has_own(&foo_42(), &"bar".into()));
+    assert!(Object::has_own(&map_with_symbol_key(), &symbol_key()));
+}
+
+#[wasm_bindgen_test]
+fn to_string() {
+    assert_eq!(Object::new().to_string(), "[object Object]");
+    assert_eq!(foo_42().to_string(), "[object Object]");
+}
+
+#[wasm_bindgen_test]
+fn is() {
+    let object = JsValue::from(Object::new());
+    assert!(Object::is(&object, &object));
+    assert!(Object::is(&JsValue::undefined(), &JsValue::undefined()));
+    assert!(Object::is(&JsValue::null(), &JsValue::null()));
+    assert!(Object::is(&JsValue::TRUE, &JsValue::TRUE));
+    assert!(Object::is(&JsValue::FALSE, &JsValue::FALSE));
+    assert!(Object::is(&"foo".into(), &"foo".into()));
+    assert!(Object::is(&JsValue::from(42), &JsValue::from(42)));
+    assert!(Object::is(&JsValue::from(NAN), &JsValue::from(NAN)));
+
+    let another_object = JsValue::from(Object::new());
+    assert!(!Object::is(&object, &another_object));
+    assert!(!Object::is(&JsValue::TRUE, &JsValue::FALSE));
+    assert!(!Object::is(&"foo".into(), &"bar".into()));
+    assert!(!Object::is(&JsValue::from(23), &JsValue::from(42)));
+}
+
+#[wasm_bindgen_test]
+fn is_extensible() {
+    let object = Object::new();
+    assert!(Object::is_extensible(&object));
+    Object::prevent_extensions(&object);
+    assert!(!Object::is_extensible(&object));
+}
+
+#[wasm_bindgen_test]
+fn is_frozen() {
+    let object = Object::new();
+    assert!(!Object::is_frozen(&object));
+    Object::freeze(&object);
+    assert!(Object::is_frozen(&object));
+}
+
+#[wasm_bindgen_test]
+fn is_sealed() {
+    let object = Object::new();
+    assert!(!Object::is_sealed(&object));
+    Object::seal(&object);
+    assert!(Object::is_sealed(&object));
+}
+
+#[wasm_bindgen_test]
+fn is_prototype_of() {
+    let foo = JsValue::from(Foo::new());
+    assert!(FOO_PROTOTYPE.is_prototype_of(&foo));
+    assert!(!BAR_PROTOTYPE.is_prototype_of(&foo));
+}
+
+#[wasm_bindgen_test]
+fn keys() {
+    let keys = Object::keys(&foo_42());
+    assert_eq!(keys.length(), 1);
+    keys.for_each(&mut |x, _, _| {
+        assert_eq!(x, "foo");
+    });
+}
+
+#[wasm_bindgen_test]
+fn values() {
+    let values = Object::values(&foo_42());
+    assert_eq!(values.length(), 1);
+    values.for_each(&mut |x, _, _| {
+        assert_eq!(x, 42);
+    });
+}
+
+#[wasm_bindgen_test]
+fn property_is_enumerable() {
+    assert!(foo_42().property_is_enumerable(&"foo".into()));
+    assert!(!foo_42().property_is_enumerable(&42.into()));
+    assert!(!Object::new().property_is_enumerable(&"foo".into()));
+}
+
+#[wasm_bindgen_test]
+fn set_prototype_of() {
+    let a = foo_42();
+    let b = foo_42();
+    Object::set_prototype_of(&a, &b);
+    assert!(b.is_prototype_of(&a.into()));
+}
+
+#[wasm_bindgen_test]
+fn to_locale_string() {
+    assert_eq!(Object::new().to_locale_string(), "[object Object]");
+}
+
+#[wasm_bindgen_test]
+fn value_of() {
+    let a = JsValue::from(foo_42());
+    let b = JsValue::from(foo_42());
+    let a2 = JsValue::from(Object::from(a.clone()).value_of());
+    assert_eq!(a, a);
+    assert_eq!(a, a2);
+    assert_ne!(a, b);
+    assert_ne!(a2, b);
+}
diff --git a/vendor/js-sys/tests/wasm/Promise.rs b/vendor/js-sys/tests/wasm/Promise.rs
new file mode 100644
index 000000000..5502a6156
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Promise.rs
@@ -0,0 +1,11 @@
+use js_sys::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen_test]
+fn promise_inheritance() {
+    let promise = Promise::new(&mut |_, _| ());
+    assert!(promise.is_instance_of::<Promise>());
+    assert!(promise.is_instance_of::<Object>());
+    let _: &Object = promise.as_ref();
+}
diff --git a/vendor/js-sys/tests/wasm/Proxy.js b/vendor/js-sys/tests/wasm/Proxy.js
new file mode 100644
index 000000000..eb0a12583
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Proxy.js
@@ -0,0 +1,11 @@
+exports.proxy_target = function() {
+  return { a: 100 };
+};
+
+exports.proxy_handler = function() {
+  return {
+    get: function(obj, prop) {
+      return prop in obj ? obj[prop] : 37;
+    }
+  };
+};
diff --git a/vendor/js-sys/tests/wasm/Proxy.rs b/vendor/js-sys/tests/wasm/Proxy.rs
new file mode 100644
index 000000000..3aca98084
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Proxy.rs
@@ -0,0 +1,45 @@
+use js_sys::*;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen(module = "tests/wasm/Proxy.js")]
+extern "C" {
+    fn proxy_target() -> JsValue;
+    fn proxy_handler() -> Object;
+
+    type Custom;
+    #[wasm_bindgen(method, getter, structural, catch)]
+    fn a(this: &Custom) -> Result<u32, JsValue>;
+    #[wasm_bindgen(method, getter, structural, catch)]
+    fn b(this: &Custom) -> Result<u32, JsValue>;
+
+    type RevocableResult;
+    #[wasm_bindgen(method, getter, structural)]
+    fn proxy(this: &RevocableResult) -> JsValue;
+    #[wasm_bindgen(method, getter, structural)]
+    fn revoke(this: &RevocableResult) -> Function;
+}
+
+#[wasm_bindgen_test]
+fn new() {
+    let proxy = Proxy::new(&proxy_target(), &proxy_handler());
+    let proxy = Custom::from(JsValue::from(proxy));
+    assert_eq!(proxy.a().unwrap(), 100);
+    assert_eq!(proxy.b().unwrap(), 37);
+}
+
+#[wasm_bindgen_test]
+fn revocable() {
+    let result = Proxy::revocable(&proxy_target(), &proxy_handler());
+    let result = RevocableResult::from(JsValue::from(result));
+    let proxy = result.proxy();
+    let revoke = result.revoke();
+
+    let obj = Custom::from(proxy);
+    assert_eq!(obj.a().unwrap(), 100);
+    assert_eq!(obj.b().unwrap(), 37);
+    revoke.apply(&JsValue::undefined(), &Array::new()).unwrap();
+    assert!(obj.a().is_err());
+    assert!(obj.b().is_err());
+    assert!(JsValue::from(obj).is_object());
+}
diff --git a/vendor/js-sys/tests/wasm/RangeError.rs b/vendor/js-sys/tests/wasm/RangeError.rs
new file mode 100644
index 000000000..97cd08b2b
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/RangeError.rs
@@ -0,0 +1,17 @@
+use js_sys::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::JsValue;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen_test]
+fn range_error() {
+    let error = RangeError::new("out of range yo");
+    assert!(error.is_instance_of::<RangeError>());
+    assert!(error.is_instance_of::<Error>());
+    assert!(error.is_instance_of::<Object>());
+    let _: &Error = error.as_ref();
+    let _: &Object = error.as_ref();
+
+    let base: &Error = error.as_ref();
+    assert_eq!(JsValue::from(base.message()), "out of range yo");
+}
diff --git a/vendor/js-sys/tests/wasm/ReferenceError.rs b/vendor/js-sys/tests/wasm/ReferenceError.rs
new file mode 100644
index 000000000..a40f5b165
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/ReferenceError.rs
@@ -0,0 +1,17 @@
+use js_sys::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::JsValue;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen_test]
+fn reference_error() {
+    let error = ReferenceError::new("bad reference, fool");
+    assert!(error.is_instance_of::<ReferenceError>());
+    assert!(error.is_instance_of::<Error>());
+    assert!(error.is_instance_of::<Object>());
+    let _: &Error = error.as_ref();
+    let _: &Object = error.as_ref();
+
+    let base: &Error = error.as_ref();
+    assert_eq!(JsValue::from(base.message()), "bad reference, fool");
+}
diff --git a/vendor/js-sys/tests/wasm/Reflect.js b/vendor/js-sys/tests/wasm/Reflect.js
new file mode 100644
index 000000000..98169e2e1
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Reflect.js
@@ -0,0 +1,41 @@
+exports.get_char_at = function() {
+  return "foo".charAt;
+};
+
+exports.Rectangle = class {
+  constructor(x, y){
+    this.x = x,
+    this.y = y
+  }
+
+  static eq(x, y) {
+    return x === y;
+  }
+};
+
+exports.Rectangle2 = class {
+  constructor(x, y){
+    this.x = x,
+    this.y = y
+  }
+
+  static eq(x, y) {
+    return x === y;
+  }
+};
+
+exports.throw_all_the_time = () => new Proxy({}, {
+  getPrototypeOf() { throw new Error("nope"); },
+  setPrototypeOf() { throw new Error("nope"); },
+  isExtensible() { throw new Error("nope"); },
+  preventExtensions() { throw new Error("nope"); },
+  getOwnPropertyDescriptor() { throw new Error("nope"); },
+  defineProperty() { throw new Error("nope"); },
+  has() { throw new Error("nope"); },
+  get() { throw new Error("nope"); },
+  set() { throw new Error("nope"); },
+  deleteProperty() { throw new Error("nope"); },
+  ownKeys() { throw new Error("nope"); },
+  apply() { throw new Error("nope"); },
+  construct() { throw new Error("nope"); },
+});
diff --git a/vendor/js-sys/tests/wasm/Reflect.rs b/vendor/js-sys/tests/wasm/Reflect.rs
new file mode 100644
index 000000000..d50629ec1
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Reflect.rs
@@ -0,0 +1,263 @@
+use js_sys::*;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen(module = "tests/wasm/Reflect.js")]
+extern "C" {
+    fn get_char_at() -> Function;
+
+    #[wasm_bindgen(js_name = Rectangle)]
+    static RECTANGLE_CLASS: Function;
+    #[wasm_bindgen(js_name = Rectangle2)]
+    static RECTANGLE2_CLASS: Function;
+
+    #[derive(Clone)]
+    type Rectangle;
+    #[wasm_bindgen(constructor)]
+    fn new() -> Rectangle;
+    #[wasm_bindgen(method, getter, structural)]
+    fn x(this: &Rectangle) -> u32;
+    #[wasm_bindgen(method, getter, structural, js_name = x)]
+    fn x_jsval(this: &Rectangle) -> JsValue;
+    #[wasm_bindgen(method, setter, structural)]
+    fn set_x(this: &Rectangle, x: u32);
+
+    fn throw_all_the_time() -> Object;
+}
+
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(js_name = prototype, js_namespace = Object)]
+    static OBJECT_PROTOTYPE: JsValue;
+    #[wasm_bindgen(js_name = prototype, js_namespace = Array)]
+    static ARRAY_PROTOTYPE: JsValue;
+
+    type DefinePropertyAttrs;
+    #[wasm_bindgen(method, setter, structural)]
+    fn set_value(this: &DefinePropertyAttrs, val: &JsValue);
+
+    type PropertyDescriptor;
+    #[wasm_bindgen(method, getter, structural)]
+    fn value(this: &PropertyDescriptor) -> JsValue;
+}
+
+#[wasm_bindgen_test]
+fn apply() {
+    let args = Array::new();
+    args.push(&3.into());
+    assert_eq!(
+        Reflect::apply(&get_char_at(), &"ponies".into(), &args).unwrap(),
+        "i"
+    );
+}
+
+#[wasm_bindgen_test]
+fn construct() {
+    let args = Array::new();
+    args.push(&10.into());
+    args.push(&10.into());
+    let instance = Reflect::construct(&RECTANGLE_CLASS, &args).unwrap();
+    assert_eq!(Rectangle::from(instance).x(), 10);
+}
+
+#[wasm_bindgen_test]
+fn construct_with_new_target() {
+    let args = Array::new();
+    args.push(&10.into());
+    args.push(&10.into());
+    let instance =
+        Reflect::construct_with_new_target(&RECTANGLE_CLASS, &args, &RECTANGLE2_CLASS).unwrap();
+    assert_eq!(Rectangle::from(instance).x(), 10);
+}
+
+#[wasm_bindgen_test]
+fn define_property() {
+    let value = DefinePropertyAttrs::from(JsValue::from(Object::new()));
+    value.set_value(&42.into());
+    let obj = Object::from(JsValue::from(value));
+    assert!(Reflect::define_property(&obj, &"key".into(), &obj).unwrap());
+}
+
+#[wasm_bindgen_test]
+fn delete_property() {
+    let r = Rectangle::new();
+    r.set_x(10);
+
+    let obj = Object::from(JsValue::from(r.clone()));
+    Reflect::delete_property(&obj, &"x".into()).unwrap();
+    assert!(r.x_jsval().is_undefined());
+
+    let array = Array::new();
+    array.push(&1.into());
+    let obj = Object::from(JsValue::from(array));
+    Reflect::delete_property(&obj, &0.into()).unwrap();
+    let array = Array::from(&JsValue::from(obj));
+    assert!(array.length() == 1);
+    array.for_each(&mut |x, _, _| assert!(x.is_undefined()));
+}
+
+#[wasm_bindgen_test]
+fn get() {
+    let r = Rectangle::new();
+    r.set_x(10);
+
+    let obj = JsValue::from(r.clone());
+    assert_eq!(Reflect::get(&obj, &"x".into()).unwrap(), 10);
+}
+
+#[wasm_bindgen_test]
+fn get_f64() {
+    let a = Array::new();
+    assert_eq!(Reflect::get_f64(&a, 0.0).unwrap(), JsValue::UNDEFINED);
+    assert_eq!(a.push(&JsValue::from_str("Hi!")), 1);
+    assert_eq!(Reflect::get_f64(&a, 0.0).unwrap(), JsValue::from_str("Hi!"));
+}
+
+#[wasm_bindgen_test]
+fn get_u32() {
+    let a = Array::new();
+    assert_eq!(Reflect::get_u32(&a, 0).unwrap(), JsValue::UNDEFINED);
+    assert_eq!(a.push(&JsValue::from_str("Hi!")), 1);
+    assert_eq!(Reflect::get_u32(&a, 0).unwrap(), JsValue::from_str("Hi!"));
+}
+
+#[wasm_bindgen_test]
+fn get_own_property_descriptor() {
+    let r = Rectangle::new();
+    r.set_x(10);
+
+    let obj = Object::from(JsValue::from(r.clone()));
+    let desc = Reflect::get_own_property_descriptor(&obj, &"x".into()).unwrap();
+    assert_eq!(PropertyDescriptor::from(desc).value(), 10);
+    let desc = Reflect::get_own_property_descriptor(&obj, &"foo".into()).unwrap();
+    assert!(desc.is_undefined());
+}
+
+#[wasm_bindgen_test]
+fn get_prototype_of() {
+    let proto = JsValue::from(Reflect::get_prototype_of(&Object::new().into()).unwrap());
+    assert_eq!(proto, *OBJECT_PROTOTYPE);
+    let proto = JsValue::from(Reflect::get_prototype_of(&Array::new().into()).unwrap());
+    assert_eq!(proto, *ARRAY_PROTOTYPE);
+}
+
+#[wasm_bindgen_test]
+fn has() {
+    let obj = JsValue::from(Rectangle::new());
+    assert!(Reflect::has(&obj, &"x".into()).unwrap());
+    assert!(!Reflect::has(&obj, &"foo".into()).unwrap());
+}
+
+#[wasm_bindgen_test]
+fn is_extensible() {
+    let obj = Object::from(JsValue::from(Rectangle::new()));
+    assert!(Reflect::is_extensible(&obj).unwrap());
+    Reflect::prevent_extensions(&obj).unwrap();
+    assert!(!Reflect::is_extensible(&obj).unwrap());
+    let obj = Object::seal(&Object::new());
+    assert!(!Reflect::is_extensible(&obj).unwrap());
+}
+
+#[wasm_bindgen_test]
+fn own_keys() {
+    let obj = JsValue::from(Rectangle::new());
+    let keys = Reflect::own_keys(&obj).unwrap();
+    assert!(keys.length() == 2);
+    keys.for_each(&mut |k, _, _| {
+        assert!(k == "x" || k == "y");
+    });
+}
+
+#[wasm_bindgen_test]
+fn prevent_extensions() {
+    let obj = Object::new();
+    Reflect::prevent_extensions(&obj).unwrap();
+    assert!(!Reflect::is_extensible(&obj).unwrap());
+}
+
+#[wasm_bindgen_test]
+fn set() {
+    let obj = JsValue::from(Object::new());
+    assert!(Reflect::set(&obj, &"key".into(), &"value".into()).unwrap());
+    assert_eq!(Reflect::get(&obj, &"key".into()).unwrap(), "value");
+}
+
+#[wasm_bindgen_test]
+fn set_f64() {
+    let a = Array::new();
+    a.push(&JsValue::from_str("Hi!"));
+
+    assert_eq!(Reflect::get_f64(&a, 0.0).unwrap(), JsValue::from_str("Hi!"));
+
+    Reflect::set_f64(&a, 0.0, &JsValue::from_str("Bye!")).unwrap();
+
+    assert_eq!(
+        Reflect::get_f64(&a, 0.0).unwrap(),
+        JsValue::from_str("Bye!")
+    );
+}
+
+#[wasm_bindgen_test]
+fn set_u32() {
+    let a = Array::new();
+    a.push(&JsValue::from_str("Hi!"));
+
+    assert_eq!(Reflect::get_u32(&a, 0).unwrap(), JsValue::from_str("Hi!"));
+
+    Reflect::set_u32(&a, 0, &JsValue::from_str("Bye!")).unwrap();
+
+    assert_eq!(Reflect::get_u32(&a, 0).unwrap(), JsValue::from_str("Bye!"));
+}
+
+#[wasm_bindgen_test]
+fn set_with_receiver() {
+    let obj1 = JsValue::from(Object::new());
+    let obj2 = JsValue::from(Object::new());
+    assert!(Reflect::set_with_receiver(&obj2, &"key".into(), &"value".into(), &obj2).unwrap());
+    assert!(Reflect::get(&obj1, &"key".into()).unwrap().is_undefined());
+    assert_eq!(Reflect::get(&obj2, &"key".into()).unwrap(), "value");
+}
+
+#[wasm_bindgen_test]
+fn set_prototype_of() {
+    let obj = Object::new();
+    assert!(Reflect::set_prototype_of(&obj, &JsValue::null()).unwrap());
+    let obj = JsValue::from(obj);
+    assert_eq!(
+        JsValue::from(Reflect::get_prototype_of(&obj).unwrap()),
+        JsValue::null()
+    );
+}
+
+#[wasm_bindgen_test]
+fn reflect_bindings_handle_proxies_that_just_throw_for_everything() {
+    let p = throw_all_the_time();
+
+    let desc = Object::new();
+    Reflect::set(desc.as_ref(), &"value".into(), &1.into()).unwrap();
+    assert!(Reflect::define_property(&p, &"a".into(), &desc).is_err());
+
+    assert!(Reflect::delete_property(&p, &"a".into()).is_err());
+
+    assert!(Reflect::get(p.as_ref(), &"a".into()).is_err());
+    assert!(Reflect::get_f64(p.as_ref(), 0.0).is_err());
+    assert!(Reflect::get_u32(p.as_ref(), 0).is_err());
+
+    assert!(Reflect::get_own_property_descriptor(&p, &"a".into()).is_err());
+
+    assert!(Reflect::get_prototype_of(p.as_ref()).is_err());
+
+    assert!(Reflect::has(p.as_ref(), &"a".into()).is_err());
+
+    assert!(Reflect::is_extensible(&p).is_err());
+
+    assert!(Reflect::own_keys(p.as_ref()).is_err());
+
+    assert!(Reflect::prevent_extensions(&p).is_err());
+
+    assert!(Reflect::set(p.as_ref(), &"a".into(), &1.into()).is_err());
+    assert!(Reflect::set_f64(p.as_ref(), 0.0, &1.into()).is_err());
+    assert!(Reflect::set_u32(p.as_ref(), 0, &1.into()).is_err());
+
+    assert!(Reflect::set_prototype_of(&p, Object::new().as_ref()).is_err());
+}
diff --git a/vendor/js-sys/tests/wasm/RegExp.rs b/vendor/js-sys/tests/wasm/RegExp.rs
new file mode 100644
index 000000000..6351a9a3f
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/RegExp.rs
@@ -0,0 +1,160 @@
+use js_sys::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen_test]
+fn regexp_inheritance() {
+    let re = RegExp::new(".", "");
+    assert!(re.is_instance_of::<RegExp>());
+    assert!(re.is_instance_of::<Object>());
+    let _: &Object = re.as_ref();
+}
+
+#[wasm_bindgen_test]
+fn exec() {
+    let re = RegExp::new("quick\\s(brown).+?(jumps)", "ig");
+    let result = re.exec("The Quick Brown Fox Jumps Over The Lazy Dog");
+
+    let mut v = vec![];
+    result.unwrap().for_each(&mut |x, _, _| v.push(x));
+
+    assert_eq!(v[0], "Quick Brown Fox Jumps");
+    assert_eq!(v[1], "Brown");
+    assert_eq!(v[2], "Jumps");
+
+    let result = re.exec("foo");
+    assert!(result.is_none());
+}
+
+#[wasm_bindgen_test]
+fn flags() {
+    let re = RegExp::new("foo", "ig");
+    assert_eq!(re.flags(), "gi");
+}
+
+#[wasm_bindgen_test]
+fn global() {
+    let re = RegExp::new("foo", "g");
+    assert!(re.global());
+
+    let re = RegExp::new("bar", "i");
+    assert!(!re.global());
+}
+
+#[wasm_bindgen_test]
+fn ignore_case() {
+    let re = RegExp::new("foo", "");
+    assert!(!re.ignore_case());
+
+    let re = RegExp::new("foo", "i");
+    assert!(re.ignore_case());
+}
+
+#[wasm_bindgen_test]
+fn input() {
+    let re = RegExp::new("hi", "g");
+    re.test("hi there!");
+    assert_eq!(RegExp::input(), "hi there!");
+}
+
+#[wasm_bindgen_test]
+fn last_index() {
+    let re = RegExp::new("hi", "g");
+    assert_eq!(re.last_index(), 0);
+
+    re.set_last_index(42);
+    assert_eq!(re.last_index(), 42);
+}
+
+#[wasm_bindgen_test]
+fn last_match() {
+    let re = RegExp::new("hi", "g");
+    re.test("hi there!");
+    assert_eq!(RegExp::last_match(), "hi");
+}
+
+#[wasm_bindgen_test]
+fn last_paren() {
+    let re = RegExp::new("(hi)", "g");
+    re.test("hi there!");
+    assert_eq!(RegExp::last_paren(), "hi");
+}
+
+#[wasm_bindgen_test]
+fn left_context() {
+    let re = RegExp::new("world", "g");
+    re.test("hello world!");
+    assert_eq!(RegExp::left_context(), "hello ");
+}
+
+#[wasm_bindgen_test]
+fn multiline() {
+    let re = RegExp::new("foo", "m");
+    assert!(re.multiline());
+}
+
+#[wasm_bindgen_test]
+fn n1_to_n9() {
+    let re = RegExp::new(
+        r"(\w+)\s(\w+)\s(\w+)\s(\w+)\s(\w+)\s(\w+)\s(\w+)\s(\w+)\s(\w+)",
+        "",
+    );
+    re.test("The Quick Brown Fox Jumps Over The Lazy Dog");
+    assert_eq!(RegExp::n1(), "The");
+    assert_eq!(RegExp::n2(), "Quick");
+    assert_eq!(RegExp::n3(), "Brown");
+    assert_eq!(RegExp::n4(), "Fox");
+    assert_eq!(RegExp::n5(), "Jumps");
+    assert_eq!(RegExp::n6(), "Over");
+    assert_eq!(RegExp::n7(), "The");
+    assert_eq!(RegExp::n8(), "Lazy");
+    assert_eq!(RegExp::n9(), "Dog");
+}
+
+#[wasm_bindgen_test]
+fn new() {
+    let re = RegExp::new("foo", "");
+    let re = RegExp::new_regexp(&re, "g");
+    assert_eq!(re.to_string(), "/foo/g");
+}
+
+#[wasm_bindgen_test]
+fn right_context() {
+    let re = RegExp::new("hello", "g");
+    re.test("hello world!");
+    assert_eq!(RegExp::right_context(), " world!");
+}
+
+#[wasm_bindgen_test]
+fn source() {
+    let re = RegExp::new("fooBar", "ig");
+    assert_eq!(re.source(), "fooBar");
+
+    let re = RegExp::new("", "ig");
+    assert_eq!(re.source(), "(?:)");
+}
+
+#[wasm_bindgen_test]
+fn sticky() {
+    let re = RegExp::new("foo", "y");
+    assert!(re.sticky());
+}
+
+#[wasm_bindgen_test]
+fn test() {
+    let re = RegExp::new("foo", "");
+    assert!(re.test("football"));
+    assert!(!re.test("bar"));
+}
+
+#[wasm_bindgen_test]
+fn to_string() {
+    let re = RegExp::new("a+b+c", "g");
+    assert_eq!(re.to_string(), "/a+b+c/g");
+}
+
+#[wasm_bindgen_test]
+fn unicode() {
+    let re = RegExp::new("\u{61}", "u");
+    assert!(re.unicode());
+}
diff --git a/vendor/js-sys/tests/wasm/Set.rs b/vendor/js-sys/tests/wasm/Set.rs
new file mode 100644
index 000000000..045e192e6
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Set.rs
@@ -0,0 +1,127 @@
+use js_sys::*;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen_test::*;
+
+fn set2vec(s: &Set) -> Vec<JsValue> {
+    let mut result = Vec::new();
+    s.for_each(&mut |x, _, _| result.push(x));
+    return result;
+}
+
+#[wasm_bindgen_test]
+fn add() {
+    let set = Set::new(&JsValue::undefined());
+    set.add(&100.into());
+    assert_eq!(set.size(), 1);
+    assert_eq!(set2vec(&set)[0], 100);
+}
+
+#[wasm_bindgen_test]
+fn clear() {
+    let set = Set::new(&JsValue::undefined());
+    set.add(&1.into());
+    set.add(&2.into());
+    set.add(&3.into());
+    assert_eq!(set.size(), 3);
+    set.clear();
+    assert_eq!(set.size(), 0);
+}
+
+#[wasm_bindgen_test]
+fn delete() {
+    let set = Set::new(&JsValue::undefined());
+    set.add(&1.into());
+    set.add(&2.into());
+    set.add(&3.into());
+
+    assert!(set.delete(&3.into()));
+    assert!(!set.delete(&3.into()));
+    assert!(!set.delete(&4.into()));
+}
+
+#[wasm_bindgen_test]
+fn for_each() {
+    let set = Set::new(&JsValue::undefined());
+    set.add(&1.into());
+    set.add(&2.into());
+    set.add(&3.into());
+
+    let v = set2vec(&set);
+    assert_eq!(v.len(), 3);
+    assert!(v.iter().any(|v| *v == 1));
+    assert!(v.iter().any(|v| *v == 2));
+    assert!(v.iter().any(|v| *v == 3));
+}
+
+#[wasm_bindgen_test]
+fn has() {
+    let set = Set::new(&JsValue::undefined());
+    set.add(&1.into());
+    set.add(&2.into());
+    set.add(&3.into());
+
+    assert!(set.has(&1.into()));
+    assert!(!set.has(&1.3.into()));
+}
+
+#[wasm_bindgen_test]
+fn new() {
+    assert_eq!(Set::new(&JsValue::undefined()).size(), 0);
+}
+
+#[wasm_bindgen_test]
+fn size() {
+    let set = Set::new(&JsValue::undefined());
+    assert_eq!(set.size(), 0);
+    set.add(&1.into());
+    assert_eq!(set.size(), 1);
+    set.add(&2.into());
+    assert_eq!(set.size(), 2);
+    set.add(&3.into());
+    assert_eq!(set.size(), 3);
+}
+
+#[wasm_bindgen_test]
+fn set_inheritance() {
+    let set = Set::new(&JsValue::undefined());
+    assert!(set.is_instance_of::<Set>());
+    assert!(set.is_instance_of::<Object>());
+    let _: &Object = set.as_ref();
+}
+
+#[wasm_bindgen_test]
+fn keys() {
+    let set = Set::new(&JsValue::undefined());
+    set.add(&1.into());
+    set.add(&2.into());
+    set.add(&3.into());
+
+    let list = set
+        .keys()
+        .into_iter()
+        .map(|e| e.unwrap())
+        .collect::<Vec<_>>();
+    assert_eq!(list.len(), 3);
+    assert!(list.iter().any(|l| *l == 1));
+    assert!(list.iter().any(|l| *l == 2));
+    assert!(list.iter().any(|l| *l == 3));
+}
+
+#[wasm_bindgen_test]
+fn values() {
+    let set = Set::new(&JsValue::undefined());
+    set.add(&1.into());
+    set.add(&2.into());
+    set.add(&3.into());
+
+    let list = set
+        .values()
+        .into_iter()
+        .map(|e| e.unwrap())
+        .collect::<Vec<_>>();
+    assert_eq!(list.len(), 3);
+    assert!(list.iter().any(|l| *l == 1));
+    assert!(list.iter().any(|l| *l == 2));
+    assert!(list.iter().any(|l| *l == 3));
+}
diff --git a/vendor/js-sys/tests/wasm/SetIterator.rs b/vendor/js-sys/tests/wasm/SetIterator.rs
new file mode 100644
index 000000000..ff853825b
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/SetIterator.rs
@@ -0,0 +1,41 @@
+use js_sys::*;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen_test]
+fn entries() {
+    let s = Set::new(&JsValue::undefined());
+    s.add(&1.into());
+    let iter = s.entries();
+    let obj = iter.next().unwrap();
+    assert!(!obj.done());
+    let array = Array::from(&obj.value());
+    assert_eq!(array.length(), 2);
+    array.for_each(&mut |a, _, _| {
+        assert_eq!(a, 1);
+    });
+
+    assert!(iter.next().unwrap().done());
+}
+
+#[wasm_bindgen_test]
+fn keys() {
+    let s = Set::new(&JsValue::undefined());
+    s.add(&1.into());
+    let iter = s.keys();
+    let obj = iter.next().unwrap();
+    assert!(!obj.done());
+    assert_eq!(obj.value(), 1);
+    assert!(iter.next().unwrap().done());
+}
+
+#[wasm_bindgen_test]
+fn values() {
+    let s = Set::new(&JsValue::undefined());
+    s.add(&1.into());
+    let iter = s.values();
+    let obj = iter.next().unwrap();
+    assert!(!obj.done());
+    assert_eq!(obj.value(), 1);
+    assert!(iter.next().unwrap().done());
+}
diff --git a/vendor/js-sys/tests/wasm/SharedArrayBuffer.js b/vendor/js-sys/tests/wasm/SharedArrayBuffer.js
new file mode 100644
index 000000000..6fa189b1c
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/SharedArrayBuffer.js
@@ -0,0 +1,3 @@
+exports.is_shared_array_buffer_supported = function () {
+    return typeof SharedArrayBuffer === 'function';
+};
diff --git a/vendor/js-sys/tests/wasm/SharedArrayBuffer.rs b/vendor/js-sys/tests/wasm/SharedArrayBuffer.rs
new file mode 100644
index 000000000..fdfd55d9b
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/SharedArrayBuffer.rs
@@ -0,0 +1,59 @@
+use js_sys::*;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen(module = "tests/wasm/SharedArrayBuffer.js")]
+extern "C" {
+    fn is_shared_array_buffer_supported() -> bool;
+}
+
+#[wasm_bindgen_test]
+fn new() {
+    if !is_shared_array_buffer_supported() {
+        return;
+    }
+    let x = SharedArrayBuffer::new(42);
+    let y: JsValue = x.into();
+    assert!(y.is_object());
+}
+
+#[wasm_bindgen_test]
+fn byte_length() {
+    if !is_shared_array_buffer_supported() {
+        return;
+    }
+    let buf = SharedArrayBuffer::new(42);
+    assert_eq!(buf.byte_length(), 42);
+}
+
+#[wasm_bindgen_test]
+fn slice() {
+    if !is_shared_array_buffer_supported() {
+        return;
+    }
+    let buf = SharedArrayBuffer::new(4);
+    let slice = buf.slice(2);
+    assert!(JsValue::from(slice).is_object());
+}
+
+#[wasm_bindgen_test]
+fn slice_with_end() {
+    if !is_shared_array_buffer_supported() {
+        return;
+    }
+    let buf = SharedArrayBuffer::new(4);
+    let slice = buf.slice_with_end(1, 2);
+    assert!(JsValue::from(slice).is_object());
+}
+
+#[wasm_bindgen_test]
+fn sharedarraybuffer_inheritance() {
+    if !is_shared_array_buffer_supported() {
+        return;
+    }
+    let buf = SharedArrayBuffer::new(4);
+    assert!(buf.is_instance_of::<SharedArrayBuffer>());
+    assert!(buf.is_instance_of::<Object>());
+    let _: &Object = buf.as_ref();
+}
diff --git a/vendor/js-sys/tests/wasm/Symbol.js b/vendor/js-sys/tests/wasm/Symbol.js
new file mode 100644
index 000000000..a66691fd9
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Symbol.js
@@ -0,0 +1,162 @@
+const assert = require('assert');
+
+exports.test_has_instance = function(sym) {
+  class Array1 {
+    static [sym](instance) {
+      return Array.isArray(instance);
+    }
+  }
+
+  assert.equal(typeof sym, "symbol");
+  assert.ok([] instanceof Array1);
+};
+
+exports.test_is_concat_spreadable = function(sym) {
+  const alpha = ['a', 'b', 'c'];
+  const numeric = [1, 2, 3];
+  let alphaNumeric = alpha.concat(numeric);
+
+  assert.deepEqual(alphaNumeric, ["a", "b", "c", 1, 2, 3]);
+
+  numeric[sym] = false;
+  alphaNumeric = alpha.concat(numeric);
+
+  assert.deepEqual(alphaNumeric, ["a", "b", "c", numeric]);
+};
+
+exports.test_iterator = function(sym) {
+  const iterable1 = new Object();
+
+  iterable1[sym] = function* () {
+    yield 1;
+    yield 2;
+    yield 3;
+  };
+
+  assert.deepEqual([...iterable1], [1, 2, 3]);
+};
+
+exports.test_async_iterator = async function(sym) {
+  const iterable1 = new Object();
+
+  iterable1[sym] = function () {
+    let done = false;
+
+    return {
+      next() {
+        if (done) {
+          return Promise.resolve({
+            done: true,
+            value: 1
+          });
+
+        } else {
+          done = true;
+
+          return Promise.resolve({
+            done: false,
+            value: 0
+          });
+        }
+      }
+    };
+  };
+
+  const values = [];
+
+  for await (let value of iterable1) {
+    values.push(value);
+  }
+
+  assert.deepEqual(values, [0]);
+};
+
+exports.test_match = function(sym) {
+  const regexp1 = /foo/;
+  assert.throws(() => '/foo/'.startsWith(regexp1));
+
+  regexp1[sym] = false;
+
+  assert.ok('/foo/'.startsWith(regexp1));
+
+  assert.equal('/baz/'.endsWith(regexp1), false);
+};
+
+exports.test_replace = function(sym) {
+  class Replace1 {
+    constructor(value) {
+      this.value = value;
+    }
+    [sym](string) {
+      return `s/${string}/${this.value}/g`;
+    }
+  }
+
+  assert.equal('foo'.replace(new Replace1('bar')), 's/foo/bar/g');
+};
+
+exports.test_search = function(sym) {
+  class Search1 {
+    constructor(value) {
+      this.value = value;
+    }
+
+    [sym](string) {
+      return string.indexOf(this.value);
+    }
+  }
+
+  assert.equal('foobar'.search(new Search1('bar')), 3);
+};
+
+exports.test_species = function(sym) {
+  class Array1 extends Array {
+    static get [sym]() { return Array; }
+  }
+
+  const a = new Array1(1, 2, 3);
+  const mapped = a.map(x => x * x);
+
+  assert.equal(mapped instanceof Array1, false);
+
+  assert.ok(mapped instanceof Array);
+};
+
+exports.test_split = function(sym) {
+  class Split1 {
+    constructor(value) {
+      this.value = value;
+    }
+
+    [sym](string) {
+      var index = string.indexOf(this.value);
+      return this.value + string.substr(0, index) + "/"
+        + string.substr(index + this.value.length);
+    }
+  }
+
+  assert.equal('foobar'.split(new Split1('foo')), 'foo/bar');
+};
+
+exports.test_to_primitive = function(sym) {
+  const object1 = {
+    [sym](hint) {
+      if (hint == 'number') {
+        return 42;
+      }
+      return null;
+    }
+  };
+
+  assert.equal(+object1, 42);
+};
+
+exports.test_to_string_tag = function(sym) {
+  class ValidatorClass {
+    get [sym]() {
+      return 'Validator';
+    }
+  }
+
+  assert.equal(Object.prototype.toString.call(new ValidatorClass()), '[object Validator]');
+};
diff --git a/vendor/js-sys/tests/wasm/Symbol.rs b/vendor/js-sys/tests/wasm/Symbol.rs
new file mode 100644
index 000000000..0f1e3d0f6
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Symbol.rs
@@ -0,0 +1,130 @@
+use js_sys::*;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen_futures::JsFuture;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen(module = "tests/wasm/Symbol.js")]
+extern "C" {
+    fn test_has_instance(sym: &Symbol);
+    fn test_is_concat_spreadable(sym: &Symbol);
+    fn test_iterator(sym: &Symbol);
+    fn test_async_iterator(sym: &Symbol) -> Promise;
+    fn test_match(sym: &Symbol);
+    fn test_replace(sym: &Symbol);
+    fn test_search(sym: &Symbol);
+    fn test_species(sym: &Symbol);
+    fn test_split(sym: &Symbol);
+    fn test_to_primitive(sym: &Symbol);
+    fn test_to_string_tag(sym: &Symbol);
+}
+
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(js_name = Symbol)]
+    fn gensym(val: JsValue) -> Symbol;
+}
+
+#[wasm_bindgen_test]
+fn has_instance() {
+    test_has_instance(&Symbol::has_instance());
+}
+
+#[wasm_bindgen_test]
+fn is_concat_spreadable() {
+    test_is_concat_spreadable(&Symbol::is_concat_spreadable());
+}
+
+#[wasm_bindgen_test]
+fn iterator() {
+    test_iterator(&Symbol::iterator());
+}
+
+#[wasm_bindgen_test]
+async fn async_iterator() {
+    JsFuture::from(test_async_iterator(&Symbol::async_iterator()))
+        .await
+        .unwrap_throw();
+}
+
+#[wasm_bindgen_test]
+fn match_() {
+    test_match(&Symbol::match_());
+}
+
+#[wasm_bindgen_test]
+fn replace() {
+    test_replace(&Symbol::replace());
+}
+
+#[wasm_bindgen_test]
+fn search() {
+    test_search(&Symbol::search());
+}
+
+#[wasm_bindgen_test]
+fn species() {
+    test_species(&Symbol::species());
+}
+
+#[wasm_bindgen_test]
+fn split() {
+    test_split(&Symbol::split());
+}
+
+#[wasm_bindgen_test]
+fn to_primitive() {
+    test_to_primitive(&Symbol::to_primitive());
+}
+
+#[wasm_bindgen_test]
+fn to_string_tag() {
+    test_to_string_tag(&Symbol::to_string_tag());
+}
+
+#[wasm_bindgen_test]
+fn for_() {
+    let foo = JsValue::from(Symbol::for_("foo"));
+    let bar = JsValue::from(Symbol::for_("bar"));
+    assert_eq!(foo, foo);
+    assert_eq!(bar, bar);
+    assert_ne!(foo, bar);
+    assert_ne!(bar, foo);
+
+    assert_eq!(Symbol::for_("mario").to_string(), "Symbol(mario)");
+}
+
+#[wasm_bindgen_test]
+fn key_for() {
+    let sym = Symbol::for_("foo");
+    assert_eq!(Symbol::key_for(&sym), "foo");
+    assert!(Symbol::key_for(&Symbol::iterator()).is_undefined());
+    assert!(Symbol::key_for(&Symbol::async_iterator()).is_undefined());
+    assert!(Symbol::key_for(&gensym(JsValue::undefined())).is_undefined());
+}
+
+#[wasm_bindgen_test]
+fn to_string() {
+    assert_eq!(Symbol::iterator().to_string(), "Symbol(Symbol.iterator)");
+    assert_eq!(
+        Symbol::async_iterator().to_string(),
+        "Symbol(Symbol.asyncIterator)"
+    );
+    assert_eq!(Symbol::for_("foo").to_string(), "Symbol(foo)");
+    assert_eq!(gensym("desc".into()).to_string(), "Symbol(desc)");
+}
+
+#[wasm_bindgen_test]
+fn unscopables() {
+    assert_eq!(
+        Symbol::unscopables().to_string(),
+        "Symbol(Symbol.unscopables)"
+    );
+}
+
+#[wasm_bindgen_test]
+fn value_of() {
+    let a = Symbol::for_("foo");
+    assert_eq!(JsValue::from(a.value_of()), JsValue::from(a));
+    let a = gensym(JsValue::undefined());
+    assert_eq!(JsValue::from(a.value_of()), JsValue::from(a));
+}
diff --git a/vendor/js-sys/tests/wasm/SyntaxError.rs b/vendor/js-sys/tests/wasm/SyntaxError.rs
new file mode 100644
index 000000000..b76b71ca6
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/SyntaxError.rs
@@ -0,0 +1,17 @@
+use js_sys::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::JsValue;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen_test]
+fn syntax_error() {
+    let error = SyntaxError::new("msg");
+    assert!(error.is_instance_of::<SyntaxError>());
+    assert!(error.is_instance_of::<Error>());
+    assert!(error.is_instance_of::<Object>());
+    let _: &Error = error.as_ref();
+    let _: &Object = error.as_ref();
+
+    let base: &Error = error.as_ref();
+    assert_eq!(JsValue::from(base.message()), "msg");
+}
diff --git a/vendor/js-sys/tests/wasm/Temporal.js b/vendor/js-sys/tests/wasm/Temporal.js
new file mode 100644
index 000000000..f006a7bb8
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Temporal.js
@@ -0,0 +1,3 @@
+exports.is_temporal_supported = function () {
+    return typeof Temporal === 'object';
+};
diff --git a/vendor/js-sys/tests/wasm/Temporal.rs b/vendor/js-sys/tests/wasm/Temporal.rs
new file mode 100644
index 000000000..5ea651bee
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/Temporal.rs
@@ -0,0 +1,81 @@
+use js_sys::*;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen(module = "tests/wasm/Temporal.js")]
+extern "C" {
+    fn is_temporal_supported() -> bool;
+}
+
+#[wasm_bindgen_test]
+fn now() {
+    if !is_temporal_supported() {
+        return;
+    }
+    let x = Temporal::Now::plain_date("iso8086");
+    let y: JsValue = x.into();
+    assert!(y.is_object());
+}
+
+#[wasm_bindgen_test]
+fn duration() {
+    if !is_temporal_supported() {
+        return;
+    }
+    let x = Temporal::Duration::from(&"PT1.00001S".into());
+    assert_eq!(x.years(), 0);
+    assert_eq!(x.microseconds(), 10);
+}
+
+#[wasm_bindgen_test]
+fn zoned_date_time() {
+    if !is_temporal_supported() {
+        return;
+    }
+    let zdt = Temporal::ZonedDateTime::from(&"2020-03-09T00:00-07:00[America/Los_Angeles]".into());
+    let earlier_day = zdt.subtract(
+        &Temporal::Duration::from(&"P1D".into()),
+        &JsValue::UNDEFINED,
+    );
+    let earlier_hours = zdt.subtract(
+        &Temporal::Duration::from(&"PT24H".into()),
+        &JsValue::UNDEFINED,
+    );
+    assert_eq!(earlier_day.hour(), 0);
+    assert_eq!(earlier_hours.hour(), 23);
+}
+
+#[wasm_bindgen_test]
+fn plain_time() {
+    if !is_temporal_supported() {
+        return;
+    }
+    let time = Temporal::PlainTime::from(&"19:39:09.068346205".into());
+    assert_eq!(time.microsecond(), 346);
+    assert_eq!(time.round(&"hour".into()).hour(), 20);
+}
+
+#[wasm_bindgen_test]
+fn plain_date() {
+    if !is_temporal_supported() {
+        return;
+    }
+    let x = Temporal::PlainDate::new(2022, 2, 2).with_calendar("persian");
+    let y = Temporal::PlainDate::new(2022, 2, 5);
+    let z = Temporal::PlainDate::from(&"-002022-02-02[u-ca=gregory]".into());
+    assert_eq!(Temporal::PlainDate::compare(&x, &y), -1);
+    assert_eq!(x.year(), 1400);
+    assert_eq!(x.month(), 11);
+    assert_eq!(x.month_code(), "M11");
+    assert_eq!(x.day(), 13);
+    assert_eq!(x.era(), "ap");
+    assert_eq!(y.era(), JsValue::UNDEFINED);
+    assert_eq!(z.era_year(), 2023i32);
+    assert_eq!(y.day_of_week(), 6);
+    assert_eq!(
+        Reflect::get(&x.get_iso_fields(), &"isoYear".into()).unwrap(),
+        2022i32
+    );
+    assert_eq!(x.in_leap_year(), false);
+}
diff --git a/vendor/js-sys/tests/wasm/TypeError.rs b/vendor/js-sys/tests/wasm/TypeError.rs
new file mode 100644
index 000000000..0fdbde1d3
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/TypeError.rs
@@ -0,0 +1,17 @@
+use js_sys::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::JsValue;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen_test]
+fn type_error() {
+    let error = TypeError::new("msg");
+    assert!(error.is_instance_of::<TypeError>());
+    assert!(error.is_instance_of::<Error>());
+    assert!(error.is_instance_of::<Object>());
+    let _: &Error = error.as_ref();
+    let _: &Object = error.as_ref();
+
+    let base: &Error = error.as_ref();
+    assert_eq!(JsValue::from(base.message()), "msg");
+}
diff --git a/vendor/js-sys/tests/wasm/TypedArray.rs b/vendor/js-sys/tests/wasm/TypedArray.rs
new file mode 100644
index 000000000..ef06a4c44
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/TypedArray.rs
@@ -0,0 +1,175 @@
+use js_sys::*;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen_test::*;
+
+macro_rules! each {
+    ($m:ident) => {
+        $m!(Uint8Array);
+        $m!(Uint8ClampedArray);
+        $m!(Uint16Array);
+        $m!(Uint32Array);
+        $m!(Int8Array);
+        $m!(Int16Array);
+        $m!(Int32Array);
+        $m!(Float32Array);
+        $m!(Float64Array);
+    };
+}
+
+macro_rules! test_inheritence {
+    ($arr:ident) => {{
+        let arr = $arr::new(&JsValue::undefined());
+        assert!(arr.is_instance_of::<$arr>());
+        let _: &Object = arr.as_ref();
+        assert!(arr.is_instance_of::<Object>());
+    }};
+}
+#[wasm_bindgen_test]
+fn inheritence() {
+    each!(test_inheritence);
+}
+
+macro_rules! test_undefined {
+    ($arr:ident) => {{
+        let arr = $arr::new(&JsValue::undefined());
+        assert_eq!(arr.length(), 0);
+        assert_eq!(arr.byte_length(), 0);
+        assert_eq!(arr.byte_offset(), 0);
+        assert!(JsValue::from(arr.buffer()).is_object());
+    }};
+}
+#[wasm_bindgen_test]
+fn new_undefined() {
+    each!(test_undefined);
+}
+
+macro_rules! test_length {
+    ($arr:ident) => {{
+        let arr = $arr::new(&4.into());
+        assert_eq!(arr.length(), 4);
+        assert!(arr.byte_length() != 0);
+        assert_eq!(arr.byte_offset(), 0);
+        assert!(JsValue::from(arr.buffer()).is_object());
+    }};
+}
+#[wasm_bindgen_test]
+fn new_length() {
+    each!(test_length);
+}
+
+macro_rules! test_subarray {
+    ($arr:ident) => {{
+        assert_eq!($arr::new(&4.into()).subarray(0, 1).length(), 1);
+    }};
+}
+#[wasm_bindgen_test]
+fn new_subarray() {
+    each!(test_subarray);
+}
+
+macro_rules! test_fill {
+    ($arr:ident) => {{
+        let arr = $arr::new(&4.into());
+        arr.for_each(&mut |x, _, _| {
+            assert_eq!(x as f64, 0.0);
+        });
+        arr.fill(2 as _, 0, 2);
+        arr.for_each(&mut |x, i, _| {
+            if i < 2 {
+                assert_eq!(x as f64, 2.0);
+            } else {
+                assert_eq!(x as f64, 0.0);
+            }
+        });
+    }};
+}
+#[wasm_bindgen_test]
+fn new_fill() {
+    each!(test_fill);
+}
+
+macro_rules! test_at {
+    ($arr:ident) => {{
+        let arr = $arr::new(&2.into());
+        arr.set_index(1, 1 as _);
+        assert_eq!(arr.at(-1).unwrap() as f64, 1 as f64);
+    }};
+}
+#[wasm_bindgen_test]
+fn new_at() {
+    each!(test_at);
+}
+
+macro_rules! test_get_set {
+    ($arr:ident) => {{
+        let arr = $arr::new(&1.into());
+        assert_eq!(arr.get_index(0) as f64, 0 as f64);
+        arr.set_index(0, 1 as _);
+        assert_eq!(arr.get_index(0) as f64, 1 as f64);
+    }};
+}
+#[wasm_bindgen_test]
+fn new_get_set() {
+    each!(test_get_set);
+}
+
+macro_rules! test_slice {
+    ($arr:ident) => {{
+        let arr = $arr::new(&4.into());
+        assert_eq!(arr.length(), 4);
+        assert_eq!(arr.slice(1, 2).length(), 1);
+    }};
+}
+#[wasm_bindgen_test]
+fn new_slice() {
+    each!(test_slice);
+}
+
+#[wasm_bindgen_test]
+fn view() {
+    let x = [1, 2, 3];
+    let array = unsafe { Int32Array::view(&x) };
+    assert_eq!(array.length(), 3);
+    array.for_each(&mut |x, i, _| {
+        assert_eq!(x, (i + 1) as i32);
+    });
+}
+
+#[wasm_bindgen_test]
+fn from() {
+    let x: Vec<i32> = vec![1, 2, 3];
+    let array = Int32Array::from(x.as_slice());
+    assert_eq!(array.length(), 3);
+    array.for_each(&mut |x, i, _| {
+        assert_eq!(x, (i + 1) as i32);
+    });
+}
+
+#[wasm_bindgen_test]
+fn copy_to() {
+    let mut x = [0; 10];
+    let array = Int32Array::new(&10.into());
+    array.fill(5, 0, 10);
+    array.copy_to(&mut x);
+    for i in x.iter() {
+        assert_eq!(*i, 5);
+    }
+}
+
+#[wasm_bindgen_test]
+fn copy_from() {
+    let x = [1, 2, 3];
+    let array = Int32Array::new(&3.into());
+    array.copy_from(&x);
+    array.for_each(&mut |x, i, _| {
+        assert_eq!(x, (i + 1) as i32);
+    });
+}
+
+#[wasm_bindgen_test]
+fn to_vec() {
+    let array = Int32Array::new(&10.into());
+    array.fill(5, 0, 10);
+    assert_eq!(array.to_vec(), vec![5, 5, 5, 5, 5, 5, 5, 5, 5, 5]);
+}
diff --git a/vendor/js-sys/tests/wasm/UriError.rs b/vendor/js-sys/tests/wasm/UriError.rs
new file mode 100644
index 000000000..0e5720c51
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/UriError.rs
@@ -0,0 +1,17 @@
+use js_sys::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::JsValue;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen_test]
+fn uri_error() {
+    let error = UriError::new("msg");
+    assert!(error.is_instance_of::<UriError>());
+    assert!(error.is_instance_of::<Error>());
+    assert!(error.is_instance_of::<Object>());
+    let _: &Error = error.as_ref();
+    let _: &Object = error.as_ref();
+
+    let base: &Error = error.as_ref();
+    assert_eq!(JsValue::from(base.message()), "msg");
+}
diff --git a/vendor/js-sys/tests/wasm/WeakMap.rs b/vendor/js-sys/tests/wasm/WeakMap.rs
new file mode 100644
index 000000000..1eab1cb9d
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/WeakMap.rs
@@ -0,0 +1,61 @@
+use js_sys::*;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen]
+extern "C" {
+    type SomeKey;
+    #[wasm_bindgen(method, setter, structural)]
+    fn set_some(this: &SomeKey, val: JsValue);
+}
+
+fn some_key() -> Object {
+    let key = SomeKey::from(JsValue::from(Object::new()));
+    key.set_some("key".into());
+    Object::from(JsValue::from(key))
+}
+
+#[wasm_bindgen_test]
+fn new() {
+    assert!(JsValue::from(WeakMap::new()).is_object());
+}
+
+#[wasm_bindgen_test]
+fn get_and_set() {
+    let map = WeakMap::new();
+    let key = some_key();
+    map.set(&key, &"value".into());
+    assert_eq!(map.get(&key), "value");
+    assert_eq!(map.get(&Object::new()), JsValue::undefined());
+    assert_eq!(map.get(&some_key()), JsValue::undefined());
+}
+
+#[wasm_bindgen_test]
+fn has() {
+    let map = WeakMap::new();
+    let key = some_key();
+    map.set(&key, &"value".into());
+    assert!(map.has(&key));
+    assert!(!map.has(&Object::new()));
+    assert!(!map.has(&some_key()));
+}
+
+#[wasm_bindgen_test]
+fn delete() {
+    let map = WeakMap::new();
+    let key = some_key();
+    assert!(!map.has(&key));
+    map.set(&key, &"value".into());
+    assert!(map.has(&key));
+    map.delete(&key);
+    assert!(!map.has(&key));
+}
+
+#[wasm_bindgen_test]
+fn weakmap_inheritance() {
+    let map = WeakMap::new();
+    assert!(map.is_instance_of::<WeakMap>());
+    assert!(map.is_instance_of::<Object>());
+    let _: &Object = map.as_ref();
+}
diff --git a/vendor/js-sys/tests/wasm/WeakSet.rs b/vendor/js-sys/tests/wasm/WeakSet.rs
new file mode 100644
index 000000000..094038b5f
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/WeakSet.rs
@@ -0,0 +1,51 @@
+use js_sys::*;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen]
+extern "C" {
+    type SomeValue;
+    #[wasm_bindgen(method, setter, structural)]
+    fn set_some(this: &SomeValue, val: JsValue);
+}
+
+fn some_value() -> Object {
+    let value = SomeValue::from(JsValue::from(Object::new()));
+    value.set_some("value".into());
+    Object::from(JsValue::from(value))
+}
+
+#[wasm_bindgen_test]
+fn new() {
+    assert!(JsValue::from(WeakSet::new()).is_object())
+}
+
+#[wasm_bindgen_test]
+fn has() {
+    let set = WeakSet::new();
+    let value = some_value();
+    assert!(!set.has(&value));
+    set.add(&value);
+    assert!(set.has(&value));
+    assert!(!set.has(&some_value()));
+}
+
+#[wasm_bindgen_test]
+fn delete() {
+    let set = WeakSet::new();
+    let value = some_value();
+    set.add(&value);
+    assert!(set.has(&value));
+    assert!(set.delete(&value));
+    assert!(!set.has(&value));
+    assert!(!set.delete(&value));
+}
+
+#[wasm_bindgen_test]
+fn weakset_inheritance() {
+    let set = WeakSet::new();
+    assert!(set.is_instance_of::<WeakSet>());
+    assert!(set.is_instance_of::<Object>());
+    let _: &Object = set.as_ref();
+}
diff --git a/vendor/js-sys/tests/wasm/WebAssembly.js b/vendor/js-sys/tests/wasm/WebAssembly.js
new file mode 100644
index 000000000..694046853
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/WebAssembly.js
@@ -0,0 +1,45 @@
+const { TextEncoder } = require("util");
+
+const data =
+  "\u0000asm\u0001\u0000\u0000\u0000\u0001\b\u0002`\u0001\u007f\u0000`\u0000" +
+  "\u0000\u0002\u0019\u0001\u0007imports\rimported_func\u0000\u0000\u0003" +
+  "\u0002\u0001\u0001\u0007\u0011\u0001\rexported_func\u0000\u0001\n\b\u0001" +
+  "\u0006\u0000A*\u0010\u0000\u000b";
+
+const encoder = new TextEncoder();
+const wasmArray = encoder.encode(data);
+
+function getWasmArray() {
+  return wasmArray;
+}
+
+function getTableObject() {
+  return { element: "anyfunc", initial: 1 }
+}
+
+function getInvalidTableObject() {
+  return { element: "anyfunc", initial: 1, maximum: 0 }
+}
+
+function getImports() {
+  return {
+    imports: {
+      imported_func: function () {
+        return 1;
+      }
+    }
+  };
+}
+
+// Polyfill `WebAssembly.instantiateStreaming` for node.
+if (!global.WebAssembly.instantiateStreaming) {
+  global.WebAssembly.instantiateStreaming =
+    (response, imports) => response.then(buf => WebAssembly.instantiate(buf, imports));
+}
+
+module.exports = {
+  getInvalidTableObject,
+  getTableObject,
+  getWasmArray,
+  getImports,
+};
diff --git a/vendor/js-sys/tests/wasm/WebAssembly.rs b/vendor/js-sys/tests/wasm/WebAssembly.rs
new file mode 100644
index 000000000..8f9a5b632
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/WebAssembly.rs
@@ -0,0 +1,205 @@
+use js_sys::*;
+use wasm_bindgen::{prelude::*, JsCast};
+use wasm_bindgen_futures::JsFuture;
+use wasm_bindgen_test::*;
+use web_sys::{Headers, Response, ResponseInit};
+
+#[wasm_bindgen(module = "tests/wasm/WebAssembly.js")]
+extern "C" {
+    #[wasm_bindgen(js_name = getWasmArray)]
+    fn get_wasm_array() -> Uint8Array;
+
+    #[wasm_bindgen(js_name = getTableObject)]
+    fn get_table_object() -> Object;
+
+    #[wasm_bindgen(js_name = getInvalidTableObject)]
+    fn get_invalid_table_object() -> Object;
+
+    #[wasm_bindgen(js_name = getImports)]
+    fn get_imports() -> Object;
+}
+
+fn get_invalid_wasm() -> JsValue {
+    ArrayBuffer::new(42).into()
+}
+
+fn get_bad_type_wasm() -> JsValue {
+    2.into()
+}
+
+fn get_valid_wasm() -> JsValue {
+    get_wasm_array().into()
+}
+
+#[wasm_bindgen_test]
+fn validate() {
+    assert!(!WebAssembly::validate(&get_invalid_wasm()).unwrap());
+
+    assert!(WebAssembly::validate(&get_bad_type_wasm()).is_err());
+}
+
+#[wasm_bindgen_test]
+async fn compile_compile_error() {
+    let p = WebAssembly::compile(&get_invalid_wasm());
+    let e = JsFuture::from(p).await.unwrap_err();
+    assert!(e.is_instance_of::<WebAssembly::CompileError>());
+}
+
+#[wasm_bindgen_test]
+async fn compile_type_error() {
+    let p = WebAssembly::compile(&get_bad_type_wasm());
+    let e = JsFuture::from(p).await.unwrap_err();
+    assert!(e.is_instance_of::<TypeError>());
+}
+
+#[wasm_bindgen_test]
+async fn compile_valid() {
+    let p = WebAssembly::compile(&get_valid_wasm());
+    let module = JsFuture::from(p).await.unwrap();
+    assert!(module.is_instance_of::<WebAssembly::Module>());
+}
+
+#[wasm_bindgen_test]
+fn module_inheritance() {
+    let module = WebAssembly::Module::new(&get_valid_wasm()).unwrap();
+    assert!(module.is_instance_of::<WebAssembly::Module>());
+    assert!(module.is_instance_of::<Object>());
+
+    let _: &Object = module.as_ref();
+}
+
+#[wasm_bindgen_test]
+fn module_error() {
+    let error = WebAssembly::Module::new(&get_invalid_wasm()).err().unwrap();
+    assert!(error.is_instance_of::<WebAssembly::CompileError>());
+
+    let error = WebAssembly::Module::new(&get_bad_type_wasm())
+        .err()
+        .unwrap();
+    assert!(error.is_instance_of::<TypeError>());
+}
+
+#[wasm_bindgen_test]
+fn module_custom_sections() {
+    let module = WebAssembly::Module::new(&get_valid_wasm()).unwrap();
+    let cust_sec = WebAssembly::Module::custom_sections(&module, "abcd");
+    assert_eq!(cust_sec.length(), 0);
+}
+
+#[wasm_bindgen_test]
+fn module_exports() {
+    let module = WebAssembly::Module::new(&get_valid_wasm()).unwrap();
+    let exports = WebAssembly::Module::exports(&module);
+    assert_eq!(exports.length(), 1);
+}
+
+#[wasm_bindgen_test]
+fn module_imports() {
+    let module = WebAssembly::Module::new(&get_valid_wasm()).unwrap();
+    let imports = WebAssembly::Module::imports(&module);
+    assert_eq!(imports.length(), 1);
+}
+
+#[wasm_bindgen_test]
+fn table_inheritance() {
+    let table = WebAssembly::Table::new(&get_table_object().into()).unwrap();
+    assert!(table.is_instance_of::<WebAssembly::Table>());
+    assert!(table.is_instance_of::<Object>());
+
+    let _: &Object = table.as_ref();
+}
+
+#[wasm_bindgen_test]
+fn table_error() {
+    let error = WebAssembly::Table::new(&get_invalid_table_object())
+        .err()
+        .unwrap();
+    assert!(error.is_instance_of::<RangeError>());
+}
+
+#[wasm_bindgen_test]
+fn table() {
+    let table = WebAssembly::Table::new(&get_table_object().into()).unwrap();
+    assert_eq!(table.length(), 1);
+
+    assert!(table.get(0).is_ok());
+    assert!(table.get(999).is_err());
+
+    table.grow(1).unwrap();
+    assert_eq!(table.length(), 2);
+
+    let f = table.get(0).unwrap();
+    table.set(1, &f).unwrap();
+}
+
+#[wasm_bindgen_test]
+fn compile_error_inheritance() {
+    let error = WebAssembly::CompileError::new("");
+    assert!(error.is_instance_of::<WebAssembly::CompileError>());
+    assert!(error.is_instance_of::<Error>());
+
+    let _: &Error = error.as_ref();
+}
+
+#[wasm_bindgen_test]
+fn link_error_inheritance() {
+    let error = WebAssembly::LinkError::new("");
+    assert!(error.is_instance_of::<WebAssembly::LinkError>());
+    assert!(error.is_instance_of::<Error>());
+
+    let _: &Error = error.as_ref();
+}
+
+#[wasm_bindgen_test]
+fn runtime_error_inheritance() {
+    let error = WebAssembly::RuntimeError::new("");
+    assert!(error.is_instance_of::<WebAssembly::RuntimeError>());
+    assert!(error.is_instance_of::<Error>());
+
+    let _: &Error = error.as_ref();
+}
+
+#[wasm_bindgen_test]
+fn webassembly_instance() {
+    let module = WebAssembly::Module::new(&get_valid_wasm()).unwrap();
+    let imports = get_imports();
+    let instance = WebAssembly::Instance::new(&module, &imports).unwrap();
+
+    // Inheritance chain is correct.
+    assert!(instance.is_instance_of::<WebAssembly::Instance>());
+    assert!(instance.is_instance_of::<Object>());
+    let _: &Object = instance.as_ref();
+
+    // Has expected exports.
+    let exports = instance.exports();
+    assert!(Reflect::has(exports.as_ref(), &"exported_func".into()).unwrap());
+}
+
+#[wasm_bindgen_test]
+async fn instantiate_module() {
+    let module = WebAssembly::Module::new(&get_valid_wasm()).unwrap();
+    let imports = get_imports();
+    let p = WebAssembly::instantiate_module(&module, &imports);
+    let inst = JsFuture::from(p).await.unwrap();
+    assert!(inst.is_instance_of::<WebAssembly::Instance>());
+}
+
+#[wasm_bindgen_test]
+fn memory_works() {
+    let obj = Object::new();
+    Reflect::set(obj.as_ref(), &"initial".into(), &1.into()).unwrap();
+    let mem = WebAssembly::Memory::new(&obj).unwrap();
+    assert!(mem.is_instance_of::<WebAssembly::Memory>());
+    assert!(mem.is_instance_of::<Object>());
+    assert!(mem.buffer().is_instance_of::<ArrayBuffer>());
+    assert_eq!(mem.grow(1), 1);
+    assert_eq!(mem.grow(2), 2);
+    assert_eq!(mem.grow(3), 4);
+    assert_eq!(
+        mem.buffer()
+            .dyn_into::<ArrayBuffer>()
+            .unwrap()
+            .byte_length(),
+        7 * 64 * 1024,
+    );
+}
diff --git a/vendor/js-sys/tests/wasm/global_fns.rs b/vendor/js-sys/tests/wasm/global_fns.rs
new file mode 100644
index 000000000..1a2c5e1c5
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/global_fns.rs
@@ -0,0 +1,90 @@
+use std::f64::{INFINITY, NAN};
+
+use js_sys::*;
+use wasm_bindgen_test::*;
+
+#[wasm_bindgen_test]
+fn test_decode_uri() {
+    let x = decode_uri("https://mozilla.org/?x=%D1%88%D0%B5%D0%BB%D0%BB%D1%8B")
+        .ok()
+        .expect("should decode URI OK");
+    assert_eq!(String::from(x), "https://mozilla.org/?x=шеллы");
+
+    assert!(decode_uri("%E0%A4%A").is_err());
+}
+
+#[wasm_bindgen_test]
+fn test_decode_uri_component() {
+    let x = decode_uri_component("%3Fx%3Dtest")
+        .ok()
+        .expect("should decode URI OK");
+    assert_eq!(String::from(x), "?x=test");
+
+    assert!(decode_uri_component("%E0%A4%A").is_err());
+}
+
+#[wasm_bindgen_test]
+fn test_encode_uri() {
+    let x = encode_uri("ABC abc 123");
+    assert_eq!(String::from(x), "ABC%20abc%20123");
+}
+
+#[wasm_bindgen_test]
+fn test_encode_uri_component() {
+    let x = encode_uri_component("?x=шеллы");
+    assert_eq!(String::from(x), "%3Fx%3D%D1%88%D0%B5%D0%BB%D0%BB%D1%8B");
+}
+
+#[wasm_bindgen_test]
+fn test_eval() {
+    let x = eval("42").ok().expect("should eval OK");
+    assert_eq!(x.as_f64().unwrap(), 42.0);
+
+    let err = eval("(function () { throw 42; }())")
+        .err()
+        .expect("eval should throw");
+    assert_eq!(err.as_f64().unwrap(), 42.0);
+}
+
+#[wasm_bindgen_test]
+fn test_is_finite() {
+    assert!(is_finite(&42.into()));
+    assert!(is_finite(&42.1.into()));
+    assert!(is_finite(&"42".into()));
+    assert!(!is_finite(&NAN.into()));
+    assert!(!is_finite(&INFINITY.into()));
+}
+
+#[wasm_bindgen_test]
+fn test_parse_int_float() {
+    let i = parse_int("42", 10);
+    assert_eq!(i as i64, 42);
+
+    let i = parse_int("42", 16);
+    assert_eq!(i as i64, 66); // 0x42 == 66
+
+    let i = parse_int("invalid int", 10);
+    assert!(i.is_nan());
+
+    let f = parse_float("123456.789");
+    assert_eq!(f, 123456.789);
+
+    let f = parse_float("invalid float");
+    assert!(f.is_nan());
+}
+
+#[wasm_bindgen_test]
+fn test_escape() {
+    assert_eq!(String::from(escape("test")), "test");
+    assert_eq!(String::from(escape("äöü")), "%E4%F6%FC");
+    assert_eq!(String::from(escape("ć")), "%u0107");
+    assert_eq!(String::from(escape("@*_+-./")), "@*_+-./");
+}
+
+#[wasm_bindgen_test]
+fn test_unescape() {
+    assert_eq!(String::from(unescape("abc123")), "abc123");
+    assert_eq!(String::from(unescape("%E4%F6%FC")), "äöü");
+    assert_eq!(String::from(unescape("%u0107")), "ć");
+    assert_eq!(String::from(unescape("@*_+-./")), "@*_+-./");
+}
diff --git a/vendor/js-sys/tests/wasm/main.rs b/vendor/js-sys/tests/wasm/main.rs
new file mode 100644
index 000000000..627c88ddf
--- /dev/null
+++ b/vendor/js-sys/tests/wasm/main.rs
@@ -0,0 +1,43 @@
+#![cfg(target_arch = "wasm32")]
+#![allow(non_snake_case)]
+
+pub mod Array;
+pub mod ArrayBuffer;
+pub mod ArrayIterator;
+pub mod BigInt;
+pub mod Boolean;
+pub mod DataView;
+pub mod Date;
+pub mod Error;
+pub mod EvalError;
+pub mod Function;
+pub mod Generator;
+pub mod Intl;
+pub mod Iterator;
+pub mod JSON;
+pub mod JsString;
+pub mod Map;
+pub mod MapIterator;
+pub mod Math;
+pub mod Number;
+pub mod Object;
+pub mod Promise;
+pub mod Proxy;
+pub mod RangeError;
+pub mod ReferenceError;
+pub mod Reflect;
+pub mod RegExp;
+pub mod Set;
+pub mod SetIterator;
+pub mod SharedArrayBuffer;
+pub mod Symbol;
+pub mod SyntaxError;
+#[cfg(js_sys_unstable_apis)]
+pub mod Temporal;
+pub mod TypeError;
+pub mod TypedArray;
+pub mod UriError;
+pub mod WeakMap;
+pub mod WeakSet;
+pub mod WebAssembly;
+pub mod global_fns;