Update broken links (#3911)

* tree-wide: update links to https://rustwasm.github.io/wasm-bindgen

https://rustwasm.github.io/wasm-bindgen -> https://wasm-bindgen.github.io/wasm-bindgen
https://rustwasm.github.io/docs/wasm-pack -> https://drager.github.io/wasm-pack/book/
https://rustwasm.github.io/wasm-pack -> https://github.com/drager/wasm-pack

Author: nikableh

examples/futures/src/main.rs

@@ -41,7 +41,7 @@ pub enum FetchState<T> {
 /// Fetches markdown from Yew's README.md.
 ///
 /// Consult the following for an example of the fetch api by the team behind web_sys:
-/// https://rustwasm.github.io/wasm-bindgen/examples/fetch.html
+/// https://wasm-bindgen.github.io/wasm-bindgen/examples/fetch.html
 async fn fetch_markdown(url: &'static str) -> Result<String, FetchError> {
     let opts = RequestInit::new();
     opts.set_method("GET");

examples/js_callback/README.md

@@ -5,14 +5,14 @@
 ## Concepts
 
 The example uses wasm-bindgen to import functionality from Javascript.
-To learn more about the subject, refer to ["The `wasm-binden` Guide"](https://rustwasm.github.io/wasm-bindgen/examples/import-js.html).
+To learn more about the subject, refer to ["The `wasm-binden` Guide"](https://wasm-bindgen.github.io/wasm-bindgen/examples/import-js.html).
 
 This example also demonstrates how to delay the loading of the snippet using Suspense.
 
 ### Serving JS files 
 
 JS files can be served when they're present in `dist` directory. There are two ways to copy these files:
-1. Use [JS Snippets](https://rustwasm.github.io/wasm-bindgen/reference/js-snippets.html). 
+1. Use [JS Snippets](https://wasm-bindgen.github.io/wasm-bindgen/reference/js-snippets.html). 
 2. Use trunk to copy the file and import it manually
 
 ### Using JS Snippets

website/community/awesome.md

@@ -127,7 +127,7 @@ description: 'Community projects built using yew'
 
 - [The WebAssembly Book](https://rustwasm.github.io/docs/book/) - Working with the web and producing .wasm files.
 - [The wasm-bindgen Guide](https://wasm-bindgen.github.io/wasm-bindgen/) - How to bind Rust and JavaScript APIs.
-- [The wasm-pack Guide](https://rustwasm.github.io/docs/wasm-pack/) - How to build and work with rust-generated WebAssembly.
+- [The wasm-pack Guide](https://drager.github.io/wasm-pack/book/) - How to build and work with rust-generated WebAssembly.
 - [Programming WebAssembly with Rust](https://pragprog.com/book/khrust/programming-webassembly-with-rust) - Includes a chapter `Advanced JavaScript Integration with Yew` on creating an app with Yew.
 - [Creative Projects for Rust Programmers](https://www.oreilly.com/library/view/creative-projects-for/9781789346220/) - Chapter 5, `Creating a Client-Side WebAssembly App Using Yew`.
 

website/docs/concepts/basic-web-technologies/wasm-bindgen.mdx

@@ -18,7 +18,7 @@ This section will explore some of these crates at a high level, to make it easie
 and use `wasm-bindgen` APIs with Yew. For a more in-depth guide to `wasm-bindgen` and its associated
 crates then check out [The `wasm-bindgen` Guide](https://wasm-bindgen.github.io/wasm-bindgen/).
 
-For documentation on the above crates check out [`wasm-bindgen docs.rs`](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen/index.html).
+For documentation on the above crates check out [`wasm-bindgen docs.rs`](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen/index.html).
 
 :::tip
 Use the `wasm-bindgen` doc.rs search to find browser APIs and JavaScript types that have been imported
@@ -97,12 +97,12 @@ These implementations allow you to call a method from `A` on an instance of `C`
 it was `&B` or `&A`.
 
 It is important to note that every single type imported using `#[wasm-bindgen]` has the same root type,
-you can think of it as the `A` in the example above, this type is [`JsValue`](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen/struct.JsValue.html) which has
+you can think of it as the `A` in the example above, this type is [`JsValue`](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen/struct.JsValue.html) which has
 its section below.
 
 _[extends section in The `wasm-bindgen` Guide](https://wasm-bindgen.github.io/wasm-bindgen/reference/attributes/on-js-imports/extends.html)_
 
-### [`JsValue`](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen/struct.JsValue.html)
+### [`JsValue`](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen/struct.JsValue.html)
 
 This is a representation of an object owned by JavaScript, this is a root catch-all type for `wasm-bindgen`.
 Because JavaScript does not have a strong type system, any type that comes from `wasm-bindgen` is a `JsValue`.
@@ -114,9 +114,9 @@ Even though `JsValue` may be accepted by a JS function, that function may still
 Passing an incorrect `JsValue` can lead to an exception which triggers a panic - so when using raw `wasm-bindgen` APIs,
 check the your JavaScript's documentation for types of inputs that will cause an exception (and a panic).
 
-_[`JsValue` documentation](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen/struct.JsValue.html)._
+_[`JsValue` documentation](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen/struct.JsValue.html)._
 
-### [`JsCast`](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen/trait.JsCast.html)
+### [`JsCast`](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen/trait.JsCast.html)
 
 Rust has a strong type system and JavaScript...doesn't 😞. For Rust to maintain these
 strong types but still be convenient, the WebAssembly group came up with a pretty neat trait `JsCast`.
@@ -132,7 +132,7 @@ unsure what type a certain object is, you can try to cast it, which returns poss
 
 A common example of this in [`web-sys`](./web-sys.mdx) is when you are trying to get the
 target of an event. You might know what the target element is, but the
-[`web_sys::Event`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.Event.html) API will always return an [`Option<web_sys::EventTarget>`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.Event.html#method.target).
+[`web_sys::Event`](https://wasm-bindgen.github.io/wasm-bindgen/api/web_sys/struct.Event.html) API will always return an [`Option<web_sys::EventTarget>`](https://wasm-bindgen.github.io/wasm-bindgen/api/web_sys/struct.Event.html#method.target).
 You will need to cast it to the element type so you can call its methods.
 
 ```rust
@@ -156,17 +156,17 @@ fn handle_event(event: Event) {
 }
 ```
 
-The [`dyn_ref`](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen/trait.JsCast.html#method.dyn_ref)
+The [`dyn_ref`](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen/trait.JsCast.html#method.dyn_ref)
 method is a checked cast that returns an `Option<&T>`, which means the original type
 can be used again if the cast failed and thus returned `None`. The
-[`dyn_into`](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen/trait.JsCast.html#method.dyn_into)
+[`dyn_into`](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen/trait.JsCast.html#method.dyn_into)
 method will consume `self`, as per convention for `into` methods in Rust, and the type returned is
 `Result<T, Self>`. If the casting fails, the original `Self` value is returned in `Err`. You can try again
 or do something else with the original type.
 
-_[`JsCast` documentation](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen/trait.JsCast.html)._
+_[`JsCast` documentation](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen/trait.JsCast.html)._
 
-### [`Closure`](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen/closure/struct.Closure.html)
+### [`Closure`](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen/closure/struct.Closure.html)
 
 The `Closure` type provides a way to transfer Rust closures to JavaScript. The closures passed to
 JavaScript must have a `'static` lifetime for soundness reasons.
@@ -176,11 +176,11 @@ closure that it refers to. Any usage of the closure in JS after the Closure has
 raise an exception.
 
 `Closure` is often used when you are working with a `js-sys` or `web-sys` API that accepts a type
-[`&js_sys::Function`](https://rustwasm.github.io/wasm-bindgen/api/js_sys/struct.Function.html).
+[`&js_sys::Function`](https://wasm-bindgen.github.io/wasm-bindgen/api/js_sys/struct.Function.html).
 An example of using a `Closure` in Yew can be found in the [Using `Closure` section](../html/events.mdx#using-closure-verbose)
 on the [Events](../html/events.mdx) page.
 
-_[`Closure` documentation](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen/closure/struct.Closure.html)._
+_[`Closure` documentation](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen/closure/struct.Closure.html)._
 
 ## [`js-sys`](https://crates.io/crates/js-sys)
 
@@ -189,7 +189,7 @@ their methods and properties.
 
 This does not include any web APIs; that's what [`web-sys`](./web-sys.mdx) is for!
 
-_[`js-sys` documentation](https://rustwasm.github.io/wasm-bindgen/api/js_sys/index.html)._
+_[`js-sys` documentation](https://wasm-bindgen.github.io/wasm-bindgen/api/js_sys/index.html)._
 
 ## [`wasm-bindgen-futures`](https://crates.io/crates/wasm-bindgen-futures)
 
@@ -201,24 +201,24 @@ with JavaScript events and JavaScript I/O primitives.
 
 There are three main interfaces in this crate currently:
 
-1. [`JsFuture`](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen_futures/struct.JsFuture.html) -
-   A type that is constructed with a [`Promise`](https://rustwasm.github.io/wasm-bindgen/api/js_sys/struct.Promise.html)
+1. [`JsFuture`](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen_futures/struct.JsFuture.html) -
+   A type that is constructed with a [`Promise`](https://wasm-bindgen.github.io/wasm-bindgen/api/js_sys/struct.Promise.html)
    and can then be used as a `Future<Output=Result<JsValue, JsValue>>`. This `Future` will resolve to `Ok` if
    the `Promise` is resolved and `Err` if the `Promise` is rejected, containing the resolved or rejected
    value from the `Promise` respectively.
 
-2. [`future_to_promise`](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen_futures/fn.future_to_promise.html) -
+2. [`future_to_promise`](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen_futures/fn.future_to_promise.html) -
    Converts a Rust `Future<Output=Result<JsValue, JsValue>>` into a
    JavaScript `Promise`. The future’s result will translate to either a resolved or rejected
    `Promise` in JavaScript.
 
-3. [`spawn_local`](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen_futures/fn.spawn_local.html) -
+3. [`spawn_local`](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen_futures/fn.spawn_local.html) -
    Spawns a `Future<Output = ()>` on the current thread. This is the best way
    to run a Future in Rust without sending it to JavaScript.
 
-_[`wasm-bindgen-futures` documentation](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen_futures/index.html)._
+_[`wasm-bindgen-futures` documentation](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen_futures/index.html)._
 
-### [`spawn_local`](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen_futures/fn.spawn_local.html)
+### [`spawn_local`](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen_futures/fn.spawn_local.html)
 
 `spawn_local` is going to be the most commonly used part of the `wasm-bindgen-futures` crate in Yew
 as this helps when using libraries that have async APIs.
@@ -240,4 +240,4 @@ spawn_local(async {
 Yew has also added support for futures in certain APIs, most notably you can create a
 `callback_future` which accepts an `async` block - this uses `spawn_local` internally.
 
-_[`spawn_local` documentation](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen_futures/fn.spawn_local.html)._
+_[`spawn_local` documentation](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen_futures/fn.spawn_local.html)._

website/docs/concepts/basic-web-technologies/web-sys.mdx

@@ -74,21 +74,21 @@ fn inheritance_of_text_area(text_area: HtmlTextAreaElement) {
 }
 ```
 
-_[Inheritance in `web-sys` in The `wasm-bindgen` Guide](https://rustwasm.github.io/wasm-bindgen/web-sys/inheritance.html)._
+_[Inheritance in `web-sys` in The `wasm-bindgen` Guide](https://wasm-bindgen.github.io/wasm-bindgen/web-sys/inheritance.html)._
 
 ## The `Node` in `NodeRef`
 
 Yew uses a [`NodeRef`](concepts/function-components/node-refs.mdx) to provide a way for keeping a reference to
 a `Node` made by the [`html!`](concepts/html/introduction.mdx) macro. The `Node` part of `NodeRef` is referring to
-[`web_sys::Node`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.Node.html). The
+[`web_sys::Node`](https://wasm-bindgen.github.io/wasm-bindgen/api/web_sys/struct.Node.html). The
 `NodeRef::get` method will return a `Option<Node>` value, however, most of the time in Yew you want
 to cast this value to a specific element so you can use its specific methods. This casting
 can be done using [`JsCast`](./wasm-bindgen.mdx#JsCast) on the `Node` value, if present, but Yew
 provides the `NodeRef::cast` method to perform this casting for convenience and so that you do not
 necessarily have to include the `wasm-bindgen` dependency for the `JsCast` trait.
 
 The two code blocks below do essentially the same thing, the first is using `NodeRef::cast` and
-the second is using [`JsCast::dyn_into`](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen/trait.JsCast.html#method.dyn_into)
+the second is using [`JsCast::dyn_into`](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen/trait.JsCast.html#method.dyn_into)
 on the `web_sys::Node` returned from `NodeRef::get`.
 
 <Tabs>

website/docs/concepts/html/events.mdx

@@ -4,7 +4,7 @@ title: 'Events'
 
 ## Introduction
 
-Yew integrates with the [`web-sys`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/) crate and
+Yew integrates with the [`web-sys`](https://wasm-bindgen.github.io/wasm-bindgen/api/web_sys/) crate and
 uses the events from that crate. The [table below](#event-types) lists all of the `web-sys`
 events that are accepted in the `html!` macro.
 
@@ -67,9 +67,9 @@ form is created. This can lead to mismatches between the event you would expect
 
     This also means that events registered by Yew will usually fire before other event listeners.
 
-[`event::current_target`]: https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.Event.html#method.current_target
-[`event::event_phase`]: https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.Event.html#method.event_phase
-[`event::capturing_phase`]: https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.Event.html#associatedconstant.CAPTURING_PHASE
+[`event::current_target`]: https://wasm-bindgen.github.io/wasm-bindgen/api/web_sys/struct.Event.html#method.current_target
+[`event::event_phase`]: https://wasm-bindgen.github.io/wasm-bindgen/api/web_sys/struct.Event.html#method.event_phase
+[`event::capturing_phase`]: https://wasm-bindgen.github.io/wasm-bindgen/api/web_sys/struct.Event.html#associatedconstant.CAPTURING_PHASE
 
 ## Typed event target
 
@@ -84,8 +84,8 @@ In event `Callback`s you may want to get the target of that event. For example,
 `change` event gives no information but is used to notify that something has changed.
 
 In Yew getting the target element in the correct type can be done in a few ways and we will go through
-them here. Calling [`web_sys::Event::target`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.Event.html#method.target)
-on an event returns an optional [`web_sys::EventTarget`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.EventTarget.html)
+them here. Calling [`web_sys::Event::target`](https://wasm-bindgen.github.io/wasm-bindgen/api/web_sys/struct.Event.html#method.target)
+on an event returns an optional [`web_sys::EventTarget`](https://wasm-bindgen.github.io/wasm-bindgen/api/web_sys/struct.EventTarget.html)
 type, which might not seem very useful when you want to know the value of your input element.
 
 In all the approaches below we are going to tackle the same problem, so it is clear where the approach
@@ -106,8 +106,8 @@ pub enum Msg {
 
 ### Using `JsCast`
 
-The [`wasm-bindgen`](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen/index.html) crate has
-a useful trait: [`JsCast`](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen/trait.JsCast.html),
+The [`wasm-bindgen`](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen/index.html) crate has
+a useful trait: [`JsCast`](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen/trait.JsCast.html),
 which allows us to hop and skip our way to the type we want, as long as it implements `JsCast`. We can
 do this cautiously, which involves some runtime checks and failure types like `Option` and `Result`,
 or we can do it dangerously.
@@ -183,13 +183,13 @@ fn MyComponent() -> Html {
 }
 ```
 
-The methods from `JsCast` are [`dyn_into`](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen/trait.JsCast.html#method.dyn_into)
-and [`unchecked_into`](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen/trait.JsCast.html#method.unchecked_into)
+The methods from `JsCast` are [`dyn_into`](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen/trait.JsCast.html#method.dyn_into)
+and [`unchecked_into`](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen/trait.JsCast.html#method.unchecked_into)
 and you can probably see, they allowed
-us to go from `EventTarget` to [`HtmlInputElement`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.HtmlInputElement.html).
+us to go from `EventTarget` to [`HtmlInputElement`](https://wasm-bindgen.github.io/wasm-bindgen/api/web_sys/struct.HtmlInputElement.html).
 The `dyn_into` method is cautious because at
 runtime it will check whether the type is actually a `HtmlInputElement` and if not return an
-`Err(JsValue)`, the [`JsValue`](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen/struct.JsValue.html)
+`Err(JsValue)`, the [`JsValue`](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen/struct.JsValue.html)
 is a catch-all type and is essentially giving you back the object to try again.
 
 At this point you might be thinking... when is the dangerous version ok to use? In the case above it
@@ -370,14 +370,14 @@ You may want to listen to an event that is not supported by Yew's `html` macro,
 
 In order to add an event listener to one of elements manually we need the help of
 [`NodeRef`](../function-components/node-refs.mdx) so that in `use_effect_with` we can add a listener using the
-[`web-sys`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/index.html) and
-[wasm-bindgen](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen/index.html) API.
+[`web-sys`](https://wasm-bindgen.github.io/wasm-bindgen/api/web_sys/index.html) and
+[wasm-bindgen](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen/index.html) API.
 
 The examples below are going to show adding listeners for the made-up `custard` event. All events
 either unsupported by yew or custom can be represented as a
-[`web_sys::Event`](https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.Event.html). If you
+[`web_sys::Event`](https://wasm-bindgen.github.io/wasm-bindgen/api/web_sys/struct.Event.html). If you
 need to access a specific method or field on a custom / unsupported event then you can use the
-methods of [`JsCast`](https://rustwasm.github.io/wasm-bindgen/api/wasm_bindgen/trait.JsCast.html)
+methods of [`JsCast`](https://wasm-bindgen.github.io/wasm-bindgen/api/wasm_bindgen/trait.JsCast.html)
 in order to convert to the type required.
 
 ### Using `Closure` (verbose)
@@ -436,7 +436,7 @@ fn MyComponent() -> Html {
 ```
 
 For more information on `Closures`, see
-[The `wasm-bindgen` Guide](https://rustwasm.github.io/wasm-bindgen/examples/closures.html).
+[The `wasm-bindgen` Guide](https://wasm-bindgen.github.io/wasm-bindgen/examples/closures.html).
 
 ### Using `gloo` (concise)
 

website/docs/getting-started/introduction.mdx

@@ -43,7 +43,7 @@ cargo install --locked trunk
 
 There are options other than Trunk that may be used for bundling Yew applications. You might want to try one of these options:
 
-- [`wasm-pack`](https://rustwasm.github.io/wasm-pack/)
+- [`wasm-pack`](https://github.com/drager/wasm-pack/)
 - [`wasm-run`](https://github.com/IMI-eRnD-Be/wasm-run)
 - [`xtask-wasm`](https://github.com/rustminded/xtask-wasm/) (still in early development)