Node.h 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676
  1. /*
  2. * Copyright (c) 2018-2022, Andreas Kling <kling@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #pragma once
  7. #include <AK/Badge.h>
  8. #include <AK/DeprecatedString.h>
  9. #include <AK/JsonObjectSerializer.h>
  10. #include <AK/RefPtr.h>
  11. #include <AK/TypeCasts.h>
  12. #include <AK/Vector.h>
  13. #include <LibWeb/DOM/AccessibilityTreeNode.h>
  14. #include <LibWeb/DOM/EventTarget.h>
  15. #include <LibWeb/DOMParsing/XMLSerializer.h>
  16. #include <LibWeb/WebIDL/ExceptionOr.h>
  17. namespace Web::DOM {
  18. enum class NodeType : u16 {
  19. INVALID = 0,
  20. ELEMENT_NODE = 1,
  21. ATTRIBUTE_NODE = 2,
  22. TEXT_NODE = 3,
  23. CDATA_SECTION_NODE = 4,
  24. ENTITY_REFERENCE_NODE = 5,
  25. ENTITY_NODE = 6,
  26. PROCESSING_INSTRUCTION_NODE = 7,
  27. COMMENT_NODE = 8,
  28. DOCUMENT_NODE = 9,
  29. DOCUMENT_TYPE_NODE = 10,
  30. DOCUMENT_FRAGMENT_NODE = 11,
  31. NOTATION_NODE = 12
  32. };
  33. enum class NameOrDescription {
  34. Name,
  35. Description
  36. };
  37. struct GetRootNodeOptions {
  38. bool composed { false };
  39. };
  40. class Node : public EventTarget {
  41. WEB_PLATFORM_OBJECT(Node, EventTarget);
  42. public:
  43. ParentNode* parent_or_shadow_host();
  44. ParentNode const* parent_or_shadow_host() const { return const_cast<Node*>(this)->parent_or_shadow_host(); }
  45. Element* parent_or_shadow_host_element();
  46. Element const* parent_or_shadow_host_element() const { return const_cast<Node*>(this)->parent_or_shadow_host_element(); }
  47. virtual ~Node();
  48. NodeType type() const { return m_type; }
  49. bool is_element() const { return type() == NodeType::ELEMENT_NODE; }
  50. bool is_text() const { return type() == NodeType::TEXT_NODE; }
  51. bool is_document() const { return type() == NodeType::DOCUMENT_NODE; }
  52. bool is_document_type() const { return type() == NodeType::DOCUMENT_TYPE_NODE; }
  53. bool is_comment() const { return type() == NodeType::COMMENT_NODE; }
  54. bool is_character_data() const { return type() == NodeType::TEXT_NODE || type() == NodeType::COMMENT_NODE; }
  55. bool is_document_fragment() const { return type() == NodeType::DOCUMENT_FRAGMENT_NODE; }
  56. bool is_parent_node() const { return is_element() || is_document() || is_document_fragment(); }
  57. bool is_slottable() const { return is_element() || is_text(); }
  58. bool is_attribute() const { return type() == NodeType::ATTRIBUTE_NODE; }
  59. bool is_cdata_section() const { return type() == NodeType::CDATA_SECTION_NODE; }
  60. virtual bool is_shadow_root() const { return false; }
  61. virtual bool requires_svg_container() const { return false; }
  62. virtual bool is_svg_container() const { return false; }
  63. virtual bool is_svg_svg_element() const { return false; }
  64. bool in_a_document_tree() const;
  65. // NOTE: This is intended for the JS bindings.
  66. u16 node_type() const { return (u16)m_type; }
  67. virtual bool is_editable() const;
  68. virtual bool is_html_element() const { return false; }
  69. virtual bool is_html_html_element() const { return false; }
  70. virtual bool is_html_anchor_element() const { return false; }
  71. virtual bool is_html_base_element() const { return false; }
  72. virtual bool is_html_body_element() const { return false; }
  73. virtual bool is_html_input_element() const { return false; }
  74. virtual bool is_html_progress_element() const { return false; }
  75. virtual bool is_html_template_element() const { return false; }
  76. virtual bool is_browsing_context_container() const { return false; }
  77. WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> pre_insert(JS::NonnullGCPtr<Node>, JS::GCPtr<Node>);
  78. WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> pre_remove(JS::NonnullGCPtr<Node>);
  79. WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> append_child(JS::NonnullGCPtr<Node>);
  80. WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> remove_child(JS::NonnullGCPtr<Node>);
  81. void insert_before(JS::NonnullGCPtr<Node> node, JS::GCPtr<Node> child, bool suppress_observers = false);
  82. void remove(bool suppress_observers = false);
  83. void remove_all_children(bool suppress_observers = false);
  84. u16 compare_document_position(JS::GCPtr<Node> other);
  85. WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> replace_child(JS::NonnullGCPtr<Node> node, JS::NonnullGCPtr<Node> child);
  86. JS::NonnullGCPtr<Node> clone_node(Document* document = nullptr, bool clone_children = false);
  87. WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> clone_node_binding(bool deep);
  88. // NOTE: This is intended for the JS bindings.
  89. bool has_child_nodes() const { return has_children(); }
  90. JS::NonnullGCPtr<NodeList> child_nodes();
  91. Vector<JS::Handle<Node>> children_as_vector() const;
  92. virtual DeprecatedFlyString node_name() const = 0;
  93. DeprecatedString base_uri() const;
  94. DeprecatedString descendant_text_content() const;
  95. DeprecatedString text_content() const;
  96. void set_text_content(DeprecatedString const&);
  97. DeprecatedString node_value() const;
  98. void set_node_value(DeprecatedString const&);
  99. Document& document() { return *m_document; }
  100. Document const& document() const { return *m_document; }
  101. JS::GCPtr<Document> owner_document() const;
  102. const HTML::HTMLAnchorElement* enclosing_link_element() const;
  103. const HTML::HTMLElement* enclosing_html_element() const;
  104. const HTML::HTMLElement* enclosing_html_element_with_attribute(DeprecatedFlyString const&) const;
  105. DeprecatedString child_text_content() const;
  106. Node& root();
  107. Node const& root() const
  108. {
  109. return const_cast<Node*>(this)->root();
  110. }
  111. Node& shadow_including_root();
  112. Node const& shadow_including_root() const
  113. {
  114. return const_cast<Node*>(this)->shadow_including_root();
  115. }
  116. bool is_connected() const;
  117. Node* parent_node() { return parent(); }
  118. Node const* parent_node() const { return parent(); }
  119. Element* parent_element();
  120. Element const* parent_element() const;
  121. virtual void inserted();
  122. virtual void removed_from(Node*) { }
  123. virtual void children_changed() { }
  124. virtual void adopted_from(Document&) { }
  125. virtual void cloned(Node&, bool) {};
  126. Layout::Node const* layout_node() const { return m_layout_node; }
  127. Layout::Node* layout_node() { return m_layout_node; }
  128. Painting::PaintableBox const* paint_box() const;
  129. Painting::Paintable const* paintable() const;
  130. void set_layout_node(Badge<Layout::Node>, JS::NonnullGCPtr<Layout::Node>);
  131. void detach_layout_node(Badge<DOM::Document>);
  132. virtual bool is_child_allowed(Node const&) const { return true; }
  133. bool needs_style_update() const { return m_needs_style_update; }
  134. void set_needs_style_update(bool);
  135. bool child_needs_style_update() const { return m_child_needs_style_update; }
  136. void set_child_needs_style_update(bool b) { m_child_needs_style_update = b; }
  137. void invalidate_style();
  138. void set_document(Badge<Document>, Document&);
  139. virtual EventTarget* get_parent(Event const&) override;
  140. template<typename T>
  141. bool fast_is() const = delete;
  142. WebIDL::ExceptionOr<void> ensure_pre_insertion_validity(JS::NonnullGCPtr<Node> node, JS::GCPtr<Node> child) const;
  143. bool is_host_including_inclusive_ancestor_of(Node const&) const;
  144. bool is_scripting_enabled() const;
  145. bool is_scripting_disabled() const;
  146. bool contains(JS::GCPtr<Node>) const;
  147. // Used for dumping the DOM Tree
  148. void serialize_tree_as_json(JsonObjectSerializer<StringBuilder>&) const;
  149. bool is_shadow_including_descendant_of(Node const&) const;
  150. bool is_shadow_including_inclusive_descendant_of(Node const&) const;
  151. bool is_shadow_including_ancestor_of(Node const&) const;
  152. bool is_shadow_including_inclusive_ancestor_of(Node const&) const;
  153. i32 id() const { return m_id; }
  154. static Node* from_id(i32 node_id);
  155. WebIDL::ExceptionOr<DeprecatedString> serialize_fragment(DOMParsing::RequireWellFormed) const;
  156. void replace_all(JS::GCPtr<Node>);
  157. void string_replace_all(DeprecatedString const&);
  158. bool is_same_node(Node const*) const;
  159. bool is_equal_node(Node const*) const;
  160. JS::NonnullGCPtr<Node> get_root_node(GetRootNodeOptions const& options = {});
  161. bool is_uninteresting_whitespace_node() const;
  162. DeprecatedString debug_description() const;
  163. size_t length() const;
  164. auto& registered_observers_list() { return m_registered_observer_list; }
  165. auto const& registered_observers_list() const { return m_registered_observer_list; }
  166. void add_registered_observer(RegisteredObserver& registered_observer) { m_registered_observer_list.append(registered_observer); }
  167. void queue_mutation_record(DeprecatedFlyString const& type, DeprecatedString attribute_name, DeprecatedString attribute_namespace, DeprecatedString old_value, JS::NonnullGCPtr<NodeList> added_nodes, JS::NonnullGCPtr<NodeList> removed_nodes, Node* previous_sibling, Node* next_sibling) const;
  168. // https://dom.spec.whatwg.org/#concept-shadow-including-descendant
  169. template<typename Callback>
  170. IterationDecision for_each_shadow_including_descendant(Callback);
  171. Node* parent() { return m_parent.ptr(); }
  172. Node const* parent() const { return m_parent.ptr(); }
  173. bool has_children() const { return m_first_child; }
  174. Node* next_sibling() { return m_next_sibling.ptr(); }
  175. Node* previous_sibling() { return m_previous_sibling.ptr(); }
  176. Node* first_child() { return m_first_child.ptr(); }
  177. Node* last_child() { return m_last_child.ptr(); }
  178. Node const* next_sibling() const { return m_next_sibling.ptr(); }
  179. Node const* previous_sibling() const { return m_previous_sibling.ptr(); }
  180. Node const* first_child() const { return m_first_child.ptr(); }
  181. Node const* last_child() const { return m_last_child.ptr(); }
  182. size_t child_count() const
  183. {
  184. size_t count = 0;
  185. for (auto* child = first_child(); child; child = child->next_sibling())
  186. ++count;
  187. return count;
  188. }
  189. Node* child_at_index(int index)
  190. {
  191. int count = 0;
  192. for (auto* child = first_child(); child; child = child->next_sibling()) {
  193. if (count == index)
  194. return child;
  195. ++count;
  196. }
  197. return nullptr;
  198. }
  199. Node const* child_at_index(int index) const
  200. {
  201. return const_cast<Node*>(this)->child_at_index(index);
  202. }
  203. // https://dom.spec.whatwg.org/#concept-tree-index
  204. size_t index() const
  205. {
  206. // The index of an object is its number of preceding siblings, or 0 if it has none.
  207. size_t index = 0;
  208. for (auto* node = previous_sibling(); node; node = node->previous_sibling())
  209. ++index;
  210. return index;
  211. }
  212. Optional<size_t> index_of_child(Node const& search_child)
  213. {
  214. VERIFY(search_child.parent() == this);
  215. size_t index = 0;
  216. auto* child = first_child();
  217. VERIFY(child);
  218. do {
  219. if (child == &search_child)
  220. return index;
  221. index++;
  222. } while (child && (child = child->next_sibling()));
  223. return {};
  224. }
  225. template<typename ChildType>
  226. Optional<size_t> index_of_child(Node const& search_child)
  227. {
  228. VERIFY(search_child.parent() == this);
  229. size_t index = 0;
  230. auto* child = first_child();
  231. VERIFY(child);
  232. do {
  233. if (!is<ChildType>(child))
  234. continue;
  235. if (child == &search_child)
  236. return index;
  237. index++;
  238. } while (child && (child = child->next_sibling()));
  239. return {};
  240. }
  241. bool is_ancestor_of(Node const&) const;
  242. bool is_inclusive_ancestor_of(Node const&) const;
  243. bool is_descendant_of(Node const&) const;
  244. bool is_inclusive_descendant_of(Node const&) const;
  245. bool is_following(Node const&) const;
  246. Node* next_in_pre_order()
  247. {
  248. if (first_child())
  249. return first_child();
  250. Node* node;
  251. if (!(node = next_sibling())) {
  252. node = parent();
  253. while (node && !node->next_sibling())
  254. node = node->parent();
  255. if (node)
  256. node = node->next_sibling();
  257. }
  258. return node;
  259. }
  260. Node* next_in_pre_order(Node const* stay_within)
  261. {
  262. if (first_child())
  263. return first_child();
  264. Node* node = static_cast<Node*>(this);
  265. Node* next = nullptr;
  266. while (!(next = node->next_sibling())) {
  267. node = node->parent();
  268. if (!node || node == stay_within)
  269. return nullptr;
  270. }
  271. return next;
  272. }
  273. Node const* next_in_pre_order() const
  274. {
  275. return const_cast<Node*>(this)->next_in_pre_order();
  276. }
  277. Node const* next_in_pre_order(Node const* stay_within) const
  278. {
  279. return const_cast<Node*>(this)->next_in_pre_order(stay_within);
  280. }
  281. Node* previous_in_pre_order()
  282. {
  283. if (auto* node = previous_sibling()) {
  284. while (node->last_child())
  285. node = node->last_child();
  286. return node;
  287. }
  288. return parent();
  289. }
  290. Node const* previous_in_pre_order() const
  291. {
  292. return const_cast<Node*>(this)->previous_in_pre_order();
  293. }
  294. bool is_before(Node const& other) const
  295. {
  296. if (this == &other)
  297. return false;
  298. for (auto* node = this; node; node = node->next_in_pre_order()) {
  299. if (node == &other)
  300. return true;
  301. }
  302. return false;
  303. }
  304. // https://dom.spec.whatwg.org/#concept-tree-preceding (Object A is 'typename U' and Object B is 'this')
  305. template<typename U>
  306. bool has_preceding_node_of_type_in_tree_order() const
  307. {
  308. for (auto* node = previous_in_pre_order(); node; node = node->previous_in_pre_order()) {
  309. if (is<U>(node))
  310. return true;
  311. }
  312. return false;
  313. }
  314. // https://dom.spec.whatwg.org/#concept-tree-following (Object A is 'typename U' and Object B is 'this')
  315. template<typename U>
  316. bool has_following_node_of_type_in_tree_order() const
  317. {
  318. for (auto* node = next_in_pre_order(); node; node = node->next_in_pre_order()) {
  319. if (is<U>(node))
  320. return true;
  321. }
  322. return false;
  323. }
  324. template<typename Callback>
  325. IterationDecision for_each_in_inclusive_subtree(Callback callback) const
  326. {
  327. if (callback(static_cast<Node const&>(*this)) == IterationDecision::Break)
  328. return IterationDecision::Break;
  329. for (auto* child = first_child(); child; child = child->next_sibling()) {
  330. if (child->for_each_in_inclusive_subtree(callback) == IterationDecision::Break)
  331. return IterationDecision::Break;
  332. }
  333. return IterationDecision::Continue;
  334. }
  335. template<typename Callback>
  336. IterationDecision for_each_in_inclusive_subtree(Callback callback)
  337. {
  338. if (callback(static_cast<Node&>(*this)) == IterationDecision::Break)
  339. return IterationDecision::Break;
  340. for (auto* child = first_child(); child; child = child->next_sibling()) {
  341. if (child->for_each_in_inclusive_subtree(callback) == IterationDecision::Break)
  342. return IterationDecision::Break;
  343. }
  344. return IterationDecision::Continue;
  345. }
  346. template<typename U, typename Callback>
  347. IterationDecision for_each_in_inclusive_subtree_of_type(Callback callback)
  348. {
  349. if (is<U>(static_cast<Node&>(*this))) {
  350. if (callback(static_cast<U&>(*this)) == IterationDecision::Break)
  351. return IterationDecision::Break;
  352. }
  353. for (auto* child = first_child(); child; child = child->next_sibling()) {
  354. if (child->template for_each_in_inclusive_subtree_of_type<U>(callback) == IterationDecision::Break)
  355. return IterationDecision::Break;
  356. }
  357. return IterationDecision::Continue;
  358. }
  359. template<typename U, typename Callback>
  360. IterationDecision for_each_in_inclusive_subtree_of_type(Callback callback) const
  361. {
  362. if (is<U>(static_cast<Node const&>(*this))) {
  363. if (callback(static_cast<U const&>(*this)) == IterationDecision::Break)
  364. return IterationDecision::Break;
  365. }
  366. for (auto* child = first_child(); child; child = child->next_sibling()) {
  367. if (child->template for_each_in_inclusive_subtree_of_type<U>(callback) == IterationDecision::Break)
  368. return IterationDecision::Break;
  369. }
  370. return IterationDecision::Continue;
  371. }
  372. template<typename Callback>
  373. IterationDecision for_each_in_subtree(Callback callback) const
  374. {
  375. for (auto* child = first_child(); child; child = child->next_sibling()) {
  376. if (child->for_each_in_inclusive_subtree(callback) == IterationDecision::Break)
  377. return IterationDecision::Break;
  378. }
  379. return IterationDecision::Continue;
  380. }
  381. template<typename Callback>
  382. IterationDecision for_each_in_subtree(Callback callback)
  383. {
  384. for (auto* child = first_child(); child; child = child->next_sibling()) {
  385. if (child->for_each_in_inclusive_subtree(callback) == IterationDecision::Break)
  386. return IterationDecision::Break;
  387. }
  388. return IterationDecision::Continue;
  389. }
  390. template<typename U, typename Callback>
  391. IterationDecision for_each_in_subtree_of_type(Callback callback)
  392. {
  393. for (auto* child = first_child(); child; child = child->next_sibling()) {
  394. if (child->template for_each_in_inclusive_subtree_of_type<U>(callback) == IterationDecision::Break)
  395. return IterationDecision::Break;
  396. }
  397. return IterationDecision::Continue;
  398. }
  399. template<typename U, typename Callback>
  400. IterationDecision for_each_in_subtree_of_type(Callback callback) const
  401. {
  402. for (auto* child = first_child(); child; child = child->next_sibling()) {
  403. if (child->template for_each_in_inclusive_subtree_of_type<U>(callback) == IterationDecision::Break)
  404. return IterationDecision::Break;
  405. }
  406. return IterationDecision::Continue;
  407. }
  408. template<typename Callback>
  409. void for_each_child(Callback callback) const
  410. {
  411. return const_cast<Node*>(this)->template for_each_child(move(callback));
  412. }
  413. template<typename Callback>
  414. void for_each_child(Callback callback)
  415. {
  416. for (auto* node = first_child(); node; node = node->next_sibling())
  417. callback(*node);
  418. }
  419. template<typename U, typename Callback>
  420. void for_each_child_of_type(Callback callback)
  421. {
  422. for (auto* node = first_child(); node; node = node->next_sibling()) {
  423. if (is<U>(node))
  424. callback(verify_cast<U>(*node));
  425. }
  426. }
  427. template<typename U, typename Callback>
  428. void for_each_child_of_type(Callback callback) const
  429. {
  430. return const_cast<Node*>(this)->template for_each_child_of_type<U>(move(callback));
  431. }
  432. template<typename U>
  433. U const* next_sibling_of_type() const
  434. {
  435. return const_cast<Node*>(this)->template next_sibling_of_type<U>();
  436. }
  437. template<typename U>
  438. inline U* next_sibling_of_type()
  439. {
  440. for (auto* sibling = next_sibling(); sibling; sibling = sibling->next_sibling()) {
  441. if (is<U>(*sibling))
  442. return &verify_cast<U>(*sibling);
  443. }
  444. return nullptr;
  445. }
  446. template<typename U>
  447. U const* previous_sibling_of_type() const
  448. {
  449. return const_cast<Node*>(this)->template previous_sibling_of_type<U>();
  450. }
  451. template<typename U>
  452. U* previous_sibling_of_type()
  453. {
  454. for (auto* sibling = previous_sibling(); sibling; sibling = sibling->previous_sibling()) {
  455. if (is<U>(*sibling))
  456. return &verify_cast<U>(*sibling);
  457. }
  458. return nullptr;
  459. }
  460. template<typename U>
  461. U const* first_child_of_type() const
  462. {
  463. return const_cast<Node*>(this)->template first_child_of_type<U>();
  464. }
  465. template<typename U>
  466. U const* last_child_of_type() const
  467. {
  468. return const_cast<Node*>(this)->template last_child_of_type<U>();
  469. }
  470. template<typename U>
  471. U* first_child_of_type()
  472. {
  473. for (auto* child = first_child(); child; child = child->next_sibling()) {
  474. if (is<U>(*child))
  475. return &verify_cast<U>(*child);
  476. }
  477. return nullptr;
  478. }
  479. template<typename U>
  480. U* last_child_of_type()
  481. {
  482. for (auto* child = last_child(); child; child = child->previous_sibling()) {
  483. if (is<U>(*child))
  484. return &verify_cast<U>(*child);
  485. }
  486. return nullptr;
  487. }
  488. template<typename U>
  489. bool has_child_of_type() const
  490. {
  491. return first_child_of_type<U>() != nullptr;
  492. }
  493. template<typename U>
  494. U const* first_ancestor_of_type() const
  495. {
  496. return const_cast<Node*>(this)->template first_ancestor_of_type<U>();
  497. }
  498. template<typename U>
  499. U* first_ancestor_of_type()
  500. {
  501. for (auto* ancestor = parent(); ancestor; ancestor = ancestor->parent()) {
  502. if (is<U>(*ancestor))
  503. return &verify_cast<U>(*ancestor);
  504. }
  505. return nullptr;
  506. }
  507. bool is_parent_of(Node const& other) const
  508. {
  509. for (auto* child = first_child(); child; child = child->next_sibling()) {
  510. if (&other == child)
  511. return true;
  512. }
  513. return false;
  514. }
  515. ErrorOr<String> accessible_name(Document const&) const;
  516. ErrorOr<String> accessible_description(Document const&) const;
  517. protected:
  518. Node(JS::Realm&, Document&, NodeType);
  519. Node(Document&, NodeType);
  520. virtual void visit_edges(Cell::Visitor&) override;
  521. virtual void finalize() override;
  522. JS::GCPtr<Document> m_document;
  523. JS::GCPtr<Layout::Node> m_layout_node;
  524. NodeType m_type { NodeType::INVALID };
  525. bool m_needs_style_update { false };
  526. bool m_child_needs_style_update { false };
  527. i32 m_id;
  528. // https://dom.spec.whatwg.org/#registered-observer-list
  529. // "Nodes have a strong reference to registered observers in their registered observer list." https://dom.spec.whatwg.org/#garbage-collection
  530. Vector<JS::NonnullGCPtr<RegisteredObserver>> m_registered_observer_list;
  531. void build_accessibility_tree(AccessibilityTreeNode& parent);
  532. ErrorOr<String> name_or_description(NameOrDescription, Document const&, HashTable<i32>&) const;
  533. private:
  534. void queue_tree_mutation_record(JS::NonnullGCPtr<NodeList> added_nodes, JS::NonnullGCPtr<NodeList> removed_nodes, Node* previous_sibling, Node* next_sibling);
  535. void insert_before_impl(JS::NonnullGCPtr<Node>, JS::GCPtr<Node> child);
  536. void append_child_impl(JS::NonnullGCPtr<Node>);
  537. void remove_child_impl(JS::NonnullGCPtr<Node>);
  538. static Optional<StringView> first_valid_id(DeprecatedString const&, Document const&);
  539. static ErrorOr<void> append_without_space(StringBuilder, StringView const&);
  540. static ErrorOr<void> append_with_space(StringBuilder, StringView const&);
  541. static ErrorOr<void> prepend_without_space(StringBuilder, StringView const&);
  542. static ErrorOr<void> prepend_with_space(StringBuilder, StringView const&);
  543. JS::GCPtr<Node> m_parent;
  544. JS::GCPtr<Node> m_first_child;
  545. JS::GCPtr<Node> m_last_child;
  546. JS::GCPtr<Node> m_next_sibling;
  547. JS::GCPtr<Node> m_previous_sibling;
  548. JS::GCPtr<NodeList> m_child_nodes;
  549. };
  550. }