103 | /// channel.create_element("div", None); 104 | /// channel.create_element("p", None); 105 | /// // this creates the

and

elements 106 | /// channel.flush(); 107 | /// ``` 108 | pub fn flush(&mut self) { 109 | self.batch.encode_op(Op::Stop); 110 | run_batch( 111 | &self.batch.msg, 112 | &self.batch.str_buf, 113 | &mut self.last_mem_size, 114 | ); 115 | self.batch.msg.clear(); 116 | self.batch.current_op_batch_idx = 0; 117 | self.batch.current_op_byte_idx = 3; 118 | self.batch.str_buf.clear(); 119 | } 120 | 121 | /// Appends a number of nodes as children of the given node. 122 | /// 123 | /// Example: 124 | /// 125 | /// ```no_run 126 | /// let mut channel = MsgChannel::default(); 127 | /// channel.create_element("div", Some(NodeId(0))); 128 | /// channel.create_element("p", None); 129 | /// // append the

element to the

element 130 | /// channel.append_child(MaybeId::Node(NodeId(0)), MaybeId::LastNode); 131 | /// channel.flush(); 132 | /// ``` 133 | pub fn append_child(&mut self, root: MaybeId, child: MaybeId) { 134 | self.batch.append_child(root, child) 135 | } 136 | 137 | /// Replace a node with another node 138 | /// 139 | /// Example: 140 | /// ```no_run 141 | /// let mut channel = MsgChannel::default(); 142 | /// channel.create_element("div", Some(NodeId(0))); 143 | /// channel.create_element("p", None); 144 | /// // replace the

element with the

element 145 | /// channel.replace_with(MaybeId::Node(NodeId(0)), MaybeId::LastNode); 146 | /// channel.flush(); 147 | /// ``` 148 | pub fn replace_with(&mut self, root: MaybeId, node: MaybeId) { 149 | self.batch.replace_with(root, node) 150 | } 151 | 152 | /// Replace a node with many nodes 153 | /// 154 | /// Example: 155 | /// ```no_run 156 | /// let mut channel = MsgChannel::default(); 157 | /// channel.create_element("div", Some(NodeId(0))); 158 | /// channel.create_element("p", None); 159 | /// // replace the

element with the

element 160 | /// channel.replace_with_nodes(MaybeId::Node(NodeId(0)), MaybeId::LastNode); 161 | /// channel.flush(); 162 | /// ``` 163 | pub fn replace_with_nodes(&mut self, root: MaybeId, nodes: &[MaybeId]) { 164 | self.batch.replace_with_nodes(root, nodes) 165 | } 166 | 167 | /// Insert a single node after a given node. 168 | /// 169 | /// Example: 170 | /// ```no_run 171 | /// let mut channel = MsgChannel::default(); 172 | /// channel.create_element("div", Some(NodeId(0))); 173 | /// channel.create_element("p", None); 174 | /// // insert the

element after the

element 175 | /// channel.insert_after(MaybeId::Node(NodeId(0)), MaybeId::LastNode); 176 | /// channel.flush(); 177 | /// ``` 178 | pub fn insert_after(&mut self, root: MaybeId, node: MaybeId) { 179 | self.batch.insert_after(root, node) 180 | } 181 | 182 | /// Insert a many nodes after a given node. 183 | /// 184 | /// Example: 185 | /// ```no_run 186 | /// let mut channel = MsgChannel::default(); 187 | /// channel.create_element("div", Some(NodeId(0))); 188 | /// channel.create_element("p", None); 189 | /// // insert the

element after the

element 190 | /// channel.insert_nodes_after(MaybeId::Node(NodeId(0)), &[MaybeId::LastNode]); 191 | /// channel.flush(); 192 | /// ``` 193 | pub fn insert_nodes_after(&mut self, root: MaybeId, nodes: &[MaybeId]) { 194 | self.batch.insert_nodes_after(root, nodes) 195 | } 196 | 197 | /// Insert a single node before a given node. 198 | /// 199 | /// Example: 200 | /// ```no_run 201 | /// let mut channel = MsgChannel::default(); 202 | /// channel.create_element("div", Some(NodeId(0))); 203 | /// channel.create_element("p", None); 204 | /// // insert the

element before the

element 205 | /// channel.insert_before(MaybeId::Node(NodeId(0)), MaybeId::LastNode); 206 | /// channel.flush(); 207 | /// ``` 208 | pub fn insert_before(&mut self, root: MaybeId, node: MaybeId) { 209 | self.batch.insert_before(root, node) 210 | } 211 | 212 | /// Insert many nodes before a given node. 213 | /// 214 | /// Example: 215 | /// ```no_run 216 | /// let mut channel = MsgChannel::default(); 217 | /// channel.create_element("div", Some(NodeId(0))); 218 | /// channel.create_element("p", None); 219 | /// // insert the

element before the

element 220 | /// channel.insert_nodes_before(MaybeId::Node(NodeId(0)), &[MaybeId::LastNode]); 221 | /// channel.flush(); 222 | /// ``` 223 | pub fn insert_nodes_before(&mut self, root: MaybeId, nodes: &[MaybeId]) { 224 | self.batch.insert_nodes_before(root, nodes) 225 | } 226 | 227 | /// Remove a node from the DOM. 228 | /// 229 | /// Example: 230 | /// ```no_run 231 | /// let mut channel = MsgChannel::default(); 232 | /// channel.create_element("p", None); 233 | /// // remove the

element 234 | /// channel.remove(MaybeId::LastNode); 235 | /// channel.flush(); 236 | /// ``` 237 | pub fn remove(&mut self, id: MaybeId) { 238 | self.batch.remove(id) 239 | } 240 | 241 | /// Create a new text node 242 | /// 243 | /// Example: 244 | /// ```no_run 245 | /// let mut channel = MsgChannel::default(); 246 | /// // create a text node with the text "Hello World" 247 | /// channel.create_text_node("Hello World", None); 248 | /// channel.flush(); 249 | pub fn create_text_node(&mut self, text: impl WritableText, id: Option) { 250 | self.batch.create_text_node(text, id) 251 | } 252 | 253 | /// Create a new element node 254 | /// 255 | /// Example: 256 | /// ```no_run 257 | /// let mut channel = MsgChannel::default(); 258 | /// // create a

element 259 | /// channel.create_element("div", None); 260 | /// channel.flush(); 261 | /// ``` 262 | pub fn create_element<'a, 'b>(&mut self, tag: impl IntoElement<'a, 'b>, id: Option) { 263 | self.batch.create_element(tag, id) 264 | } 265 | 266 | /// Set the textcontent of a node. 267 | /// 268 | /// Example: 269 | /// ```no_run 270 | /// let mut channel = MsgChannel::default(); 271 | /// // create a text node with the text "Hello World" 272 | /// channel.create_text_node("Hello ", None); 273 | /// // set the text content of the text node to "Hello World!!!" 274 | /// channel.set_text_content("World!!!", MaybeId::LastNode); 275 | /// channel.flush(); 276 | /// ``` 277 | pub fn set_text(&mut self, text: impl WritableText, root: MaybeId) { 278 | self.batch.set_text(text, root) 279 | } 280 | 281 | /// Set the value of a node's attribute. 282 | /// 283 | /// Example: 284 | /// ```no_run 285 | /// let mut channel = MsgChannel::default(); 286 | /// // create a

element 287 | /// channel.create_element("div", None); 288 | /// // set the attribute "id" to "my-div" on the

element 289 | /// channel.set_attribute(Attribute::id, "my-div", MaybeId::LastNode); 290 | /// channel.flush(); 291 | /// ``` 292 | pub fn set_attribute<'a, 'b>( 293 | &mut self, 294 | attr: impl IntoAttribue<'a, 'b>, 295 | value: impl WritableText, 296 | root: MaybeId, 297 | ) { 298 | self.batch.set_attribute(attr, value, root) 299 | } 300 | 301 | /// Remove an attribute from a node. 302 | /// 303 | /// Example: 304 | /// ```no_run 305 | /// let mut channel = MsgChannel::default(); 306 | /// // create a

element 307 | /// channel.create_element("div", None); 308 | /// channel.set_attribute(Attribute::id, "my-div", MaybeId::LastNode); 309 | /// // remove the attribute "id" from the

element 310 | /// channel.remove_attribute(Attribute::id, MaybeId::LastNode); 311 | /// channel.flush(); 312 | /// ``` 313 | pub fn remove_attribute<'a, 'b>(&mut self, attr: impl IntoAttribue<'a, 'b>, root: MaybeId) { 314 | self.batch.remove_attribute(attr, root) 315 | } 316 | 317 | /// Clone a node and store it with a new id. 318 | /// 319 | /// Example: 320 | /// ```no_run 321 | /// let mut channel = MsgChannel::default(); 322 | /// // create a

element 323 | /// channel.create_element("div", None); 324 | /// // clone the

element and store it with the id 1 325 | /// channel.clone_node(MaybeId::LastNode, Some(NodeId(1))); 326 | /// channel.flush(); 327 | /// ``` 328 | pub fn clone_node(&mut self, id: MaybeId, new_id: MaybeId) { 329 | self.batch.clone_node(id, new_id) 330 | } 331 | 332 | /// Move the last node to the first child 333 | /// 334 | /// Example: 335 | /// ```no_run 336 | /// let mut channel = MsgChannel::default(); 337 | /// // create a element:

to the

346 | /// channel.first_child(); 347 | /// // operatons modifing the

element... 348 | /// channel.flush(); 349 | /// ``` 350 | pub fn first_child(&mut self) { 351 | self.batch.first_child() 352 | } 353 | 354 | /// Move the last node to the next sibling 355 | /// 356 | /// Example: 357 | /// ```no_run 358 | /// let mut channel = MsgChannel::default(); 359 | /// // create a element:

to the

369 | /// channel.first_child(); 370 | /// // move from the

to the
371 | /// channel.next_sibling(); 372 | /// // operatons modifing the
element... 373 | /// channel.flush(); 374 | /// ``` 375 | pub fn next_sibling(&mut self) { 376 | self.batch.next_sibling() 377 | } 378 | 379 | /// Move the last node to the parent node 380 | /// 381 | /// Example: 382 | /// ```no_run 383 | /// let mut channel = MsgChannel::default(); 384 | /// // create a element:
385 | /// channel.build_full_element( 386 | /// ElementBuilder::new("div".into()) 387 | /// .children(&[ 388 | /// ElementBuilder::new(Element::p.into()) 389 | /// .id(NodeId(0)) 390 | /// .into(), 391 | /// ]), 392 | /// ); 393 | /// // move to the
element 394 | /// channel.set_last_node(NodeId(0)); 395 | /// // move from the
to the
396 | /// channel.parent_node(); 397 | /// // operatons modifing the
element... 398 | /// channel.flush(); 399 | /// ``` 400 | pub fn parent_node(&mut self) { 401 | self.batch.parent_node() 402 | } 403 | 404 | /// Store the last node with the given id. This is useful when traversing the document tree. 405 | /// 406 | /// Example: 407 | /// ```no_run 408 | /// let mut channel = MsgChannel::default(); 409 | /// // create a element without an id 410 | /// channel.create_element("div", None); 411 | /// // store the
element with the id 0 412 | /// channel.set_last_node(NodeId(0)); 413 | /// channel.flush(); 414 | /// ``` 415 | pub fn store_with_id(&mut self, id: NodeId) { 416 | self.batch.store_with_id(id) 417 | } 418 | 419 | /// Set the last node to the given id. The last node can be used to traverse the document tree without passing objects between wasm and js every time. 420 | /// 421 | /// Example: 422 | /// ```no_run 423 | /// let mut channel = MsgChannel::default(); 424 | /// // create a element:

to the

438 | /// channel.first_child(); 439 | /// // store the

element with the id 0 440 | /// channel.store_with_id(NodeId(0)); 441 | /// // move from the

to the

442 | /// channel.first_child(); 443 | /// // update something in the

element... 444 | /// // restore the

element 445 | /// channel.set_last_node(NodeId(0)); 446 | /// // move from the

to the
447 | /// channel.next_sibling(); 448 | /// // operatons modifing the
element... 449 | /// channel.flush(); 450 | /// ``` 451 | pub fn set_last_node(&mut self, id: NodeId) { 452 | self.batch.set_last_node(id) 453 | } 454 | 455 | /// Build a full element, slightly more efficent than creating the element creating the element with `create_element` and then setting the attributes. 456 | /// 457 | /// Example: 458 | /// ```rust 459 | /// let mut channel = MsgChannel::default(); 460 | /// // create an element using sledgehammer 461 | /// channel.build_full_element( 462 | /// ElementBuilder::new("div".into()) 463 | /// .id(NodeId(0)) 464 | /// .attrs(&[(Attribute::style.into(), "color: blue")]) 465 | /// .children(&[ 466 | /// ElementBuilder::new(Element::p.into()) 467 | /// .into(), 468 | /// TextBuilder::new("Hello from sledgehammer!").into(), 469 | /// ]), 470 | /// ); 471 | /// channel.flush(); 472 | /// ``` 473 | pub fn build_full_element(&mut self, el: ElementBuilder) { 474 | self.batch.build_full_element(el) 475 | } 476 | 477 | /// Build a text node 478 | /// 479 | /// Example: 480 | /// ```rust 481 | /// let mut channel = MsgChannel::default(); 482 | /// // create an element using sledgehammer 483 | /// channel.build_text_node( 484 | /// TextBuilder::new("div".into()) 485 | /// ); 486 | /// channel.flush(); 487 | /// ``` 488 | pub fn build_text_node(&mut self, text: TextBuilder) { 489 | self.batch.build_text_node(text) 490 | } 491 | 492 | /// Set a style property on a node. 493 | /// 494 | /// Example: 495 | /// ```rust 496 | /// let mut channel = MsgChannel::default(); 497 | /// channel.create_element("div", None); 498 | /// // set the style property "color" to "blue" 499 | /// channel.set_style("color", "blue", MaybeId::LastNode); 500 | /// channel.flush(); 501 | /// ``` 502 | pub fn set_style(&mut self, style: &str, value: &str, id: MaybeId) { 503 | self.batch.set_style(style, value, id) 504 | } 505 | 506 | /// Remove a style property from a node. 507 | /// 508 | /// Example: 509 | /// ```rust 510 | /// let mut channel = MsgChannel::default(); 511 | /// channel.create_element("div", None); 512 | /// channel.set_style("color", "blue", MaybeId::LastNode); 513 | /// // remove the color style 514 | /// channel.remove_style("color", MaybeId::LastNode); 515 | /// channel.flush(); 516 | /// ``` 517 | pub fn remove_style(&mut self, style: &str, id: MaybeId) { 518 | self.batch.remove_style(style, id) 519 | } 520 | 521 | /// Adds a batch of operations to the current batch. 522 | /// 523 | /// Example: 524 | /// ```rust 525 | /// let mut channel = MsgChannel::default(); 526 | /// let mut batch = Batch::default(); 527 | /// batch.create_element("div", None); 528 | /// // add the batch to the channel 529 | /// channel.append(batch); 530 | /// channel.flush(); 531 | /// ``` 532 | pub fn append(&mut self, batch: Batch) { 533 | self.batch.append(batch); 534 | } 535 | 536 | /// IMPORTANT: This method is exicuted immediatly and does not wait for the next flush 537 | /// 538 | /// Run a batch of operations on the DOM immediately. This only runs the operations that are in the batch, not the operations that are queued in the [`MsgChannel`]. 539 | /// 540 | /// Example: 541 | /// ```rust 542 | /// let mut channel = MsgChannel::default(); 543 | /// let mut batch = Batch::default(); 544 | /// batch.create_element("div", None); 545 | /// // add the batch to the channel 546 | /// channel.run_batch(&batch.finalize()); 547 | /// ``` 548 | pub fn run_batch(&mut self, batch: impl PreparedBatch) { 549 | run_batch(batch.msg(), batch.str(), &mut self.last_mem_size); 550 | } 551 | } 552 | 553 | fn run_batch(msg: &[u8], str_buf: &[u8], last_mem_size: &mut usize) { 554 | debug_assert_eq!(0usize.to_le_bytes().len(), 32 / 8); 555 | let msg_ptr = msg.as_ptr() as usize; 556 | let str_ptr = str_buf.as_ptr() as usize; 557 | // the pointer will only be updated when the message vec is resized, so we have a flag to check if the pointer has changed to avoid unnecessary decoding 558 | if unsafe { MSG_METADATA_PTR } == 255 { 559 | // this is the first message, so we need to encode all the metadata 560 | unsafe { 561 | let mut_ptr_ptr: mut usize = std::mem::transmute(MSG_PTR_PTR); 562 | mut_ptr_ptr = msg_ptr; 563 | let mut_metadata_ptr: mut u8 = std::mem::transmute(MSG_METADATA_PTR); 564 | // the first bit encodes if the msg pointer has changed 565 | mut_metadata_ptr = 1; 566 | let mut_str_ptr_ptr: mut usize = std::mem::transmute(STR_PTR_PTR); 567 | mut_str_ptr_ptr = str_ptr as usize; 568 | // the second bit encodes if the str pointer has changed 569 | mut_metadata_ptr |= 2; 570 | } 571 | } else { 572 | if unsafe { MSG_PTR_PTR } != msg_ptr { 573 | unsafe { 574 | let mut_ptr_ptr: mut usize = std::mem::transmute(MSG_PTR_PTR); 575 | mut_ptr_ptr = msg_ptr; 576 | let mut_ptr_ptr: mut u8 = std::mem::transmute(MSG_METADATA_PTR); 577 | // the first bit encodes if the msg pointer has changed 578 | mut_ptr_ptr = 1; 579 | } 580 | } else { 581 | unsafe { 582 | let mut_ptr_ptr: mut u8 = std::mem::transmute(MSG_METADATA_PTR); 583 | // the first bit encodes if the msg pointer has changed 584 | mut_ptr_ptr = 0; 585 | } 586 | } 587 | if unsafe { STR_PTR_PTR } != str_ptr { 588 | unsafe { 589 | let mut_str_ptr_ptr: mut usize = std::mem::transmute(STR_PTR_PTR); 590 | mut_str_ptr_ptr = str_ptr as usize; 591 | let mut_metadata_ptr: mut u8 = std::mem::transmute(MSG_METADATA_PTR); 592 | // the second bit encodes if the str pointer has changed 593 | mut_metadata_ptr |= 1 << 1; 594 | } 595 | } 596 | } 597 | unsafe { 598 | let mut_metadata_ptr: mut u8 = std::mem::transmute(MSG_METADATA_PTR); 599 | if !str_buf.is_empty() { 600 | // the third bit encodes if there is any strings 601 | mut_metadata_ptr |= 1 << 2; 602 | let mut_str_len_ptr: mut usize = std::mem::transmute(STR_LEN_PTR); 603 | mut_str_len_ptr = str_buf.len() as usize; 604 | if mut_str_len_ptr < 100 { 605 | // the fourth bit encodes if the strings are entirely ascii and small 606 | mut_metadata_ptr |= (str_buf.is_ascii() as u8) << 3; 607 | } 608 | } 609 | } 610 | let new_mem_size = core::arch::wasm32::memory_size(0); 611 | // we need to update the memory if the memory has grown 612 | if new_mem_size != last_mem_size { 613 | last_mem_size = new_mem_size; 614 | update_last_memory(wasm_bindgen::memory()); 615 | } 616 | 617 | work_last_created(); 618 | } 619 | -------------------------------------------------------------------------------- /web/src/lib.rs: -------------------------------------------------------------------------------- 1 | //!
2 | //! 3 | //! 4 | //! 6 | //! 7 | //! 8 | //! 9 | //! 11 | //! 12 | //! 13 | //! 14 | //! 16 | //! 17 | //!
18 | //! 19 | //!Breaking the WASM<->JS peformance boundry one brick at a time 20 | //!### Status: There are some holes in the wall. 21 | //! 22 | //!# What is Sledgehammer? 23 | //!Sledgehammer provides faster rust bindings for dom manipuations by batching calls to js. 24 | //! 25 | //! # Getting started 26 | //! - All operations go through a [`MsgChannel`] which handles the communication with js. 27 | //! 28 | //!# Benchmarks 29 | //! 30 | //!- run this benchmark in your browser: [dom operation time only (not paint time) js-framework-benchmark](https://demonthos.github.io/wasm_bindgen_sledgehammer/) 31 | //! 32 | //!This gives more consistant results than the official js-framework-benchmark because it excludes the variation in paint time. Because sledgehammer and wasm-bindgen implementations result in the same dom calls they should have the same paint time. 33 | //! 34 | //!- A few runs of [a fork of the js-framework-benchmark:](https://github.com/demonthos/js-framework-benchmark/tree/testing) 35 | //!
36 | //! 37 | //! 38 | //! 39 | //!
40 | //! 41 | //!# How does this compare to wasm-bindgen/web-sys: 42 | //!wasm-bindgen is a lot more general, and ergonomic to use than sledgehammer. It has bindings to a lot of apis that sledgehammer does not. For most users wasm-bindgen is a beter choice. Sledgehammer is specifically designed for web frameworks that want low level, fast access to the dom. 43 | //! 44 | //!# Why is it fast? 45 | //! 46 | //!## String decoding 47 | //! 48 | //!- Decoding strings are expensive to decode, but the cost doesn't change much with the size of the string. Wasm-bindgen calls TextDecoder.decode for every string. Sledehammer only calls TextEncoder.decode once per batch. 49 | //! 50 | //!- If the string is small it is faster to decode the string in javascript to avoid the constant overhead of TextDecoder.decode 51 | //! 52 | //!- See this benchmark: 53 | //! 54 | //!## Single byte attributes and elements 55 | //! 56 | //!- In addition to making string decoding cheaper, sledehammer also uses less strings. All elements and attribute names are encoded as a single byte instead of a string and then turned back into a string in the javascipt intepreter. 57 | //! 58 | //!- To allow for custom elements and attributes, you can pass in a &str instead of a Attribute or Element enum. 59 | //! 60 | //!## Byte encoded operations 61 | //! 62 | //!- In sledehammer every operation is encoded as a sequence of bytes packed into an array. Every operation takes 1 byte plus whatever data is required for it. 63 | //! 64 | //!- Booleans are encoded as part of the operation byte to reduce the number of bytes read. 65 | //! 66 | //!- Each operation is encoded in a batch of four as a u32. Getting a number from an array buffer has a high constant cost, but getting a u32 instead of a u8 is not more expensive. Sledgehammer reads the u32 and then splits it into the 4 individual bytes. 67 | //! 68 | //!- See this benchmark: 69 | //! 70 | //!## Minimize passing ids 71 | //! 72 | //!- A common set of operations for webframeworks to perform is traversing dom nodes after cloning them. Instead of assigning an id to every node, sledgehammer allows you to perform operations on the last node that was created or navigated to. This means traversing id takes only one byte per operation instead of 5. 73 | 74 | #![allow(non_camel_case_types)] 75 | 76 | pub mod channel; 77 | 78 | pub use channel::MsgChannel; 79 | pub use sledgehammer_encoder::{ 80 | Attribute, Element, ElementBuilder, IntoAttribue, IntoElement, MaybeId, NodeBuilder, NodeId, 81 | StaticBatch, TextBuilder, WritableText, 82 | }; 83 | 84 | pub use sledgehammer_encoder; 85 | 86 | use wasm_bindgen::prelude::; 87 | use web_sys::Node; 88 | 89 | #[used] 90 | static mut MSG_PTR: usize = 0; 91 | #[used] 92 | static mut MSG_PTR_PTR: const usize = unsafe { &MSG_PTR } as const usize; 93 | #[used] 94 | static mut MSG_POS_UPDATED: u8 = 255; 95 | #[used] 96 | static mut MSG_METADATA_PTR: const u8 = unsafe { &MSG_POS_UPDATED } as const u8; 97 | #[used] 98 | static mut STR_PTR: usize = 0; 99 | #[used] 100 | static mut STR_PTR_PTR: const usize = unsafe { &STR_PTR } as const usize; 101 | #[used] 102 | static mut STR_LEN: usize = 0; 103 | #[used] 104 | static mut STR_LEN_PTR: const usize = unsafe { &STR_LEN } as *const usize; 105 | 106 | #[wasm_bindgen(module = "/interpreter_opt.js")] 107 | // #[wasm_bindgen(module = "/interpreter.js")] 108 | extern "C" { 109 | fn work_last_created(); 110 | 111 | fn update_last_memory(mem: JsValue); 112 | 113 | pub(crate) type JsInterpreter; 114 | 115 | #[wasm_bindgen(constructor)] 116 | pub(crate) fn new( 117 | mem: JsValue, 118 | msg_pos_updated_ptr: usize, 119 | msg_ptr: usize, 120 | str_ptr: usize, 121 | str_len_ptr: usize, 122 | ) -> JsInterpreter; 123 | 124 | #[wasm_bindgen(method)] 125 | pub(crate) fn UpdateMemory(this: &JsInterpreter, mem: JsValue); 126 | 127 | #[wasm_bindgen(method)] 128 | pub(crate) fn SetNode(this: &JsInterpreter, id: u32, node: Node); 129 | 130 | #[allow(unused)] 131 | #[wasm_bindgen(method)] 132 | pub(crate) fn GetNode(this: &JsInterpreter, id: u32) -> Node; 133 | } 134 | --------------------------------------------------------------------------------