@dvaji/cheerox 0.1.1 → 0.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (37) hide show
  1. package/Cargo.lock +1 -4
  2. package/Cargo.toml +3 -2
  3. package/THIRD_PARTY_NOTICES.md +5 -3
  4. package/cheerox.darwin-arm64.node +0 -0
  5. package/cheerox.darwin-x64.node +0 -0
  6. package/cheerox.linux-arm64-gnu.node +0 -0
  7. package/cheerox.linux-arm64-musl.node +0 -0
  8. package/cheerox.linux-x64-gnu.node +0 -0
  9. package/cheerox.linux-x64-musl.node +0 -0
  10. package/cheerox.win32-arm64-msvc.node +0 -0
  11. package/cheerox.win32-x64-msvc.node +0 -0
  12. package/dist/{cheerio-compat-BS--qPzw.mjs → cheerio-compat-BKkfJEAr.mjs} +2 -2
  13. package/dist/{cheerio-compat-BS--qPzw.mjs.map → cheerio-compat-BKkfJEAr.mjs.map} +1 -1
  14. package/dist/{cheerio-compat-DSwBAJ1s.cjs → cheerio-compat-DcnYK9OB.cjs} +2 -2
  15. package/dist/{cheerio-compat-DSwBAJ1s.cjs.map → cheerio-compat-DcnYK9OB.cjs.map} +1 -1
  16. package/dist/cheerio-compat.cjs +1 -1
  17. package/dist/cheerio-compat.mjs +1 -1
  18. package/native/src/lib.rs +2 -1
  19. package/native/vendor/README.md +12 -3
  20. package/native/vendor/scraper-0.24.0/Cargo.toml +52 -0
  21. package/native/vendor/scraper-0.24.0/LICENSE +15 -0
  22. package/native/vendor/scraper-0.24.0/src/element_ref/element.rs +212 -0
  23. package/native/vendor/scraper-0.24.0/src/element_ref/mod.rs +236 -0
  24. package/native/vendor/scraper-0.24.0/src/element_ref/serializable.rs +15 -0
  25. package/native/vendor/scraper-0.24.0/src/error/utils.rs +91 -0
  26. package/native/vendor/scraper-0.24.0/src/error.rs +118 -0
  27. package/native/vendor/scraper-0.24.0/src/html/mod.rs +270 -0
  28. package/native/vendor/scraper-0.24.0/src/html/serializable.rs +27 -0
  29. package/native/vendor/scraper-0.24.0/src/html/tree_sink.rs +285 -0
  30. package/native/vendor/scraper-0.24.0/src/lib.rs +180 -0
  31. package/native/vendor/scraper-0.24.0/src/node/serializable.rs +52 -0
  32. package/native/vendor/scraper-0.24.0/src/node.rs +465 -0
  33. package/native/vendor/scraper-0.24.0/src/selectable.rs +70 -0
  34. package/native/vendor/scraper-0.24.0/src/selector.rs +290 -0
  35. package/package.json +1 -1
  36. package/scripts/check-release.mjs +2 -2
  37. package/scripts/generate-notices.mjs +10 -4
@@ -0,0 +1,118 @@
1
+ //! Custom error types for diagnostics
2
+ //! Includes re-exported error types from dependencies
3
+
4
+ mod utils;
5
+
6
+ use std::{error::Error, fmt::Display};
7
+
8
+ use cssparser::{BasicParseErrorKind, ParseErrorKind, Token};
9
+ use selectors::parser::SelectorParseErrorKind;
10
+
11
+ /// Error type that is returned when calling `Selector::parse`
12
+ #[derive(Debug, Clone)]
13
+ pub enum SelectorErrorKind<'a> {
14
+ /// A `Token` was not expected
15
+ UnexpectedToken(Token<'a>),
16
+
17
+ /// End-Of-Line was unexpected
18
+ EndOfLine,
19
+
20
+ /// `@` rule is invalid
21
+ InvalidAtRule(String),
22
+
23
+ /// The body of an `@` rule is invalid
24
+ InvalidAtRuleBody,
25
+
26
+ /// The qualified rule is invalid
27
+ QualRuleInvalid,
28
+
29
+ /// Expected a `::` for a pseudoelement
30
+ ExpectedColonOnPseudoElement(Token<'a>),
31
+
32
+ /// Expected an identity for a pseudoelement
33
+ ExpectedIdentityOnPseudoElement(Token<'a>),
34
+
35
+ /// A `SelectorParseErrorKind` error that isn't really supposed to happen did
36
+ UnexpectedSelectorParseError(SelectorParseErrorKind<'a>),
37
+ }
38
+
39
+ impl<'a> From<cssparser::ParseError<'a, SelectorParseErrorKind<'a>>> for SelectorErrorKind<'a> {
40
+ fn from(original: cssparser::ParseError<'a, SelectorParseErrorKind<'a>>) -> Self {
41
+ // NOTE: This could be improved, but I dont
42
+ // exactly know how
43
+ match original.kind {
44
+ ParseErrorKind::Basic(err) => SelectorErrorKind::from(err),
45
+ ParseErrorKind::Custom(err) => SelectorErrorKind::from(err),
46
+ }
47
+ }
48
+ }
49
+
50
+ impl<'a> From<BasicParseErrorKind<'a>> for SelectorErrorKind<'a> {
51
+ fn from(err: BasicParseErrorKind<'a>) -> Self {
52
+ match err {
53
+ BasicParseErrorKind::UnexpectedToken(token) => Self::UnexpectedToken(token),
54
+ BasicParseErrorKind::EndOfInput => Self::EndOfLine,
55
+ BasicParseErrorKind::AtRuleInvalid(rule) => Self::InvalidAtRule(rule.to_string()),
56
+ BasicParseErrorKind::AtRuleBodyInvalid => Self::InvalidAtRuleBody,
57
+ BasicParseErrorKind::QualifiedRuleInvalid => Self::QualRuleInvalid,
58
+ }
59
+ }
60
+ }
61
+
62
+ impl<'a> From<SelectorParseErrorKind<'a>> for SelectorErrorKind<'a> {
63
+ fn from(err: SelectorParseErrorKind<'a>) -> Self {
64
+ match err {
65
+ SelectorParseErrorKind::PseudoElementExpectedColon(token) => {
66
+ Self::ExpectedColonOnPseudoElement(token)
67
+ }
68
+ SelectorParseErrorKind::PseudoElementExpectedIdent(token) => {
69
+ Self::ExpectedIdentityOnPseudoElement(token)
70
+ }
71
+ other => Self::UnexpectedSelectorParseError(other),
72
+ }
73
+ }
74
+ }
75
+
76
+ impl Display for SelectorErrorKind<'_> {
77
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
78
+ write!(
79
+ f,
80
+ "{}",
81
+ match self {
82
+ Self::UnexpectedToken(token) => {
83
+ format!("Token {:?} was not expected", utils::render_token(token))
84
+ }
85
+ Self::EndOfLine => "Unexpected EOL".to_string(),
86
+ Self::InvalidAtRule(rule) => format!("Invalid @-rule {rule:?}"),
87
+ Self::InvalidAtRuleBody => "The body of an @-rule was invalid".to_string(),
88
+ Self::QualRuleInvalid => "The qualified name was invalid".to_string(),
89
+ Self::ExpectedColonOnPseudoElement(token) => format!(
90
+ "Expected a ':' token for pseudoelement, got {:?} instead",
91
+ utils::render_token(token)
92
+ ),
93
+ Self::ExpectedIdentityOnPseudoElement(token) => format!(
94
+ "Expected identity for pseudoelement, got {:?} instead",
95
+ utils::render_token(token)
96
+ ),
97
+ Self::UnexpectedSelectorParseError(err) => format!(
98
+ "Unexpected error occurred. Please report this to the developer\n{err:#?}"
99
+ ),
100
+ }
101
+ )
102
+ }
103
+ }
104
+
105
+ impl Error for SelectorErrorKind<'_> {
106
+ fn description(&self) -> &str {
107
+ match self {
108
+ Self::UnexpectedToken(_) => "Token was not expected",
109
+ Self::EndOfLine => "Unexpected EOL",
110
+ Self::InvalidAtRule(_) => "Invalid @-rule",
111
+ Self::InvalidAtRuleBody => "The body of an @-rule was invalid",
112
+ Self::QualRuleInvalid => "The qualified name was invalid",
113
+ Self::ExpectedColonOnPseudoElement(_) => "Missing colon character on pseudoelement",
114
+ Self::ExpectedIdentityOnPseudoElement(_) => "Missing pseudoelement identity",
115
+ Self::UnexpectedSelectorParseError(_) => "Unexpected error",
116
+ }
117
+ }
118
+ }
@@ -0,0 +1,270 @@
1
+ //! HTML documents and fragments.
2
+
3
+ #[cfg(feature = "errors")]
4
+ use std::borrow::Cow;
5
+ use std::fmt;
6
+ use std::iter::FusedIterator;
7
+
8
+ use ego_tree::iter::Nodes;
9
+ use ego_tree::Tree;
10
+ use html5ever::serialize::SerializeOpts;
11
+ use html5ever::tree_builder::QuirksMode;
12
+ use html5ever::{driver, serialize, QualName};
13
+ use selectors::matching::SelectorCaches;
14
+ use tendril::TendrilSink;
15
+
16
+ use crate::selector::Selector;
17
+ use crate::{ElementRef, Node};
18
+
19
+ pub use tree_sink::HtmlTreeSink;
20
+
21
+ /// An HTML tree.
22
+ ///
23
+ /// Parsing does not fail hard. Instead, the `quirks_mode` is set and errors are added to the
24
+ /// `errors` field. The `tree` will still be populated as best as possible.
25
+ ///
26
+ /// Implements the `TreeSink` trait from the `html5ever` crate, which allows HTML to be parsed.
27
+ #[derive(Debug, Clone, PartialEq, Eq)]
28
+ pub struct Html {
29
+ #[cfg(feature = "errors")]
30
+ /// Parse errors.
31
+ pub errors: Vec<Cow<'static, str>>,
32
+
33
+ /// The quirks mode.
34
+ pub quirks_mode: QuirksMode,
35
+
36
+ /// The node tree.
37
+ pub tree: Tree<Node>,
38
+ }
39
+
40
+ impl Html {
41
+ /// Creates an empty HTML document.
42
+ pub fn new_document() -> Self {
43
+ Html {
44
+ #[cfg(feature = "errors")]
45
+ errors: Vec::new(),
46
+ quirks_mode: QuirksMode::NoQuirks,
47
+ tree: Tree::new(Node::Document),
48
+ }
49
+ }
50
+
51
+ /// Creates an empty HTML fragment.
52
+ pub fn new_fragment() -> Self {
53
+ Html {
54
+ #[cfg(feature = "errors")]
55
+ errors: Vec::new(),
56
+ quirks_mode: QuirksMode::NoQuirks,
57
+ tree: Tree::new(Node::Fragment),
58
+ }
59
+ }
60
+
61
+ /// Parses a string of HTML as a document.
62
+ ///
63
+ /// This is a convenience method for the following:
64
+ ///
65
+ /// ```
66
+ /// # extern crate html5ever;
67
+ /// # extern crate scraper;
68
+ /// # extern crate tendril;
69
+ /// # fn main() {
70
+ /// # let document = "";
71
+ /// use html5ever::driver::{self, ParseOpts};
72
+ /// use scraper::{Html, HtmlTreeSink};
73
+ /// use tendril::TendrilSink;
74
+ ///
75
+ /// let parser = driver::parse_document(HtmlTreeSink::new(Html::new_document()), ParseOpts::default());
76
+ /// let html = parser.one(document);
77
+ /// # }
78
+ /// ```
79
+ pub fn parse_document(document: &str) -> Self {
80
+ let parser =
81
+ driver::parse_document(HtmlTreeSink::new(Self::new_document()), Default::default());
82
+ parser.one(document)
83
+ }
84
+
85
+ /// Parses a string of HTML as a fragment.
86
+ pub fn parse_fragment(fragment: &str) -> Self {
87
+ let parser = driver::parse_fragment(
88
+ HtmlTreeSink::new(Self::new_fragment()),
89
+ Default::default(),
90
+ QualName::new(None, ns!(html), local_name!("body")),
91
+ Vec::new(),
92
+ false,
93
+ );
94
+ parser.one(fragment)
95
+ }
96
+
97
+ /// Returns an iterator over elements matching a selector.
98
+ pub fn select<'a, 'b>(&'a self, selector: &'b Selector) -> Select<'a, 'b> {
99
+ Select {
100
+ inner: self.tree.nodes(),
101
+ selector,
102
+ caches: Default::default(),
103
+ }
104
+ }
105
+
106
+ /// Returns the root `<html>` element.
107
+ pub fn root_element(&self) -> ElementRef<'_> {
108
+ let root_node = self
109
+ .tree
110
+ .root()
111
+ .children()
112
+ .find(|child| child.value().is_element())
113
+ .expect("html node missing");
114
+ ElementRef::wrap(root_node).unwrap()
115
+ }
116
+
117
+ /// Serialize entire document into HTML.
118
+ pub fn html(&self) -> String {
119
+ let opts = SerializeOpts {
120
+ scripting_enabled: false, // It's not clear what this does.
121
+ traversal_scope: serialize::TraversalScope::IncludeNode,
122
+ create_missing_parent: false,
123
+ };
124
+ let mut buf = Vec::new();
125
+ serialize(&mut buf, self, opts).unwrap();
126
+ String::from_utf8(buf).unwrap()
127
+ }
128
+ }
129
+
130
+ /// Iterator over elements matching a selector.
131
+ pub struct Select<'a, 'b> {
132
+ inner: Nodes<'a, Node>,
133
+ selector: &'b Selector,
134
+ caches: SelectorCaches,
135
+ }
136
+
137
+ impl fmt::Debug for Select<'_, '_> {
138
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
139
+ fmt.debug_struct("Select")
140
+ .field("inner", &self.inner)
141
+ .field("selector", &self.selector)
142
+ .field("caches", &"..")
143
+ .finish()
144
+ }
145
+ }
146
+
147
+ impl Clone for Select<'_, '_> {
148
+ fn clone(&self) -> Self {
149
+ Self {
150
+ inner: self.inner.clone(),
151
+ selector: self.selector,
152
+ caches: Default::default(),
153
+ }
154
+ }
155
+ }
156
+
157
+ impl<'a> Iterator for Select<'a, '_> {
158
+ type Item = ElementRef<'a>;
159
+
160
+ fn next(&mut self) -> Option<ElementRef<'a>> {
161
+ for node in self.inner.by_ref() {
162
+ if let Some(element) = ElementRef::wrap(node) {
163
+ if element.parent().is_some()
164
+ && self
165
+ .selector
166
+ .matches_with_scope_and_cache(&element, None, &mut self.caches)
167
+ {
168
+ return Some(element);
169
+ }
170
+ }
171
+ }
172
+ None
173
+ }
174
+
175
+ fn size_hint(&self) -> (usize, Option<usize>) {
176
+ let (_lower, upper) = self.inner.size_hint();
177
+
178
+ (0, upper)
179
+ }
180
+ }
181
+
182
+ impl DoubleEndedIterator for Select<'_, '_> {
183
+ fn next_back(&mut self) -> Option<Self::Item> {
184
+ for node in self.inner.by_ref().rev() {
185
+ if let Some(element) = ElementRef::wrap(node) {
186
+ if element.parent().is_some()
187
+ && self
188
+ .selector
189
+ .matches_with_scope_and_cache(&element, None, &mut self.caches)
190
+ {
191
+ return Some(element);
192
+ }
193
+ }
194
+ }
195
+ None
196
+ }
197
+ }
198
+
199
+ impl FusedIterator for Select<'_, '_> {}
200
+
201
+ mod serializable;
202
+ mod tree_sink;
203
+
204
+ #[cfg(test)]
205
+ mod tests {
206
+ use super::Html;
207
+ use super::Selector;
208
+
209
+ #[test]
210
+ fn root_element_fragment() {
211
+ let html = Html::parse_fragment(r#"<a href="http://github.com">1</a>"#);
212
+ let root_ref = html.root_element();
213
+ let href = root_ref
214
+ .select(&Selector::parse("a").unwrap())
215
+ .next()
216
+ .unwrap();
217
+ assert_eq!(href.inner_html(), "1");
218
+ assert_eq!(href.value().attr("href").unwrap(), "http://github.com");
219
+ }
220
+
221
+ #[test]
222
+ fn root_element_document_doctype() {
223
+ let html = Html::parse_document("<!DOCTYPE html>\n<title>abc</title>");
224
+ let root_ref = html.root_element();
225
+ let title = root_ref
226
+ .select(&Selector::parse("title").unwrap())
227
+ .next()
228
+ .unwrap();
229
+ assert_eq!(title.inner_html(), "abc");
230
+ }
231
+
232
+ #[test]
233
+ fn root_element_document_comment() {
234
+ let html = Html::parse_document("<!-- comment --><title>abc</title>");
235
+ let root_ref = html.root_element();
236
+ let title = root_ref
237
+ .select(&Selector::parse("title").unwrap())
238
+ .next()
239
+ .unwrap();
240
+ assert_eq!(title.inner_html(), "abc");
241
+ }
242
+
243
+ #[test]
244
+ fn select_is_reversible() {
245
+ let html = Html::parse_document("<p>element1</p><p>element2</p><p>element3</p>");
246
+ let selector = Selector::parse("p").unwrap();
247
+ let result: Vec<_> = html
248
+ .select(&selector)
249
+ .rev()
250
+ .map(|e| e.inner_html())
251
+ .collect();
252
+ assert_eq!(result, vec!["element3", "element2", "element1"]);
253
+ }
254
+
255
+ #[test]
256
+ fn select_has_a_size_hint() {
257
+ let html = Html::parse_document("<p>element1</p><p>element2</p><p>element3</p>");
258
+ let selector = Selector::parse("p").unwrap();
259
+ let (lower, upper) = html.select(&selector).size_hint();
260
+ assert_eq!(lower, 0);
261
+ assert_eq!(upper, Some(10));
262
+ }
263
+
264
+ #[cfg(feature = "atomic")]
265
+ #[test]
266
+ fn html_is_send() {
267
+ fn send_sync<S: Send>() {}
268
+ send_sync::<Html>();
269
+ }
270
+ }
@@ -0,0 +1,27 @@
1
+ use std::io::Error;
2
+
3
+ use html5ever::serialize::{Serialize, Serializer, TraversalScope};
4
+
5
+ use crate::Html;
6
+
7
+ impl Serialize for Html {
8
+ fn serialize<S: Serializer>(
9
+ &self,
10
+ serializer: &mut S,
11
+ traversal_scope: TraversalScope,
12
+ ) -> Result<(), Error> {
13
+ crate::node::serializable::serialize(self.tree.root(), serializer, traversal_scope)
14
+ }
15
+ }
16
+
17
+ #[cfg(test)]
18
+ mod tests {
19
+ use crate::Html;
20
+
21
+ #[test]
22
+ fn test_serialize() {
23
+ let src = r#"<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"></head><body><p>Hello world!</p></body></html>"#;
24
+ let html = Html::parse_document(src);
25
+ assert_eq!(html.html(), src);
26
+ }
27
+ }
@@ -0,0 +1,285 @@
1
+ use super::Html;
2
+ use crate::node::{Comment, Doctype, Element, Node, ProcessingInstruction, Text};
3
+ use crate::tendril_util::make as make_tendril;
4
+ use ego_tree::NodeId;
5
+ use html5ever::tendril::StrTendril;
6
+ use html5ever::tree_builder::{ElementFlags, NodeOrText, QuirksMode, TreeSink};
7
+ use html5ever::Attribute;
8
+ use html5ever::QualName;
9
+ use std::borrow::Cow;
10
+ use std::cell::{Ref, RefCell};
11
+
12
+ /// Wraps `Html` instances as sinks to drive parsing
13
+ #[derive(Debug)]
14
+ pub struct HtmlTreeSink(pub RefCell<Html>);
15
+
16
+ impl HtmlTreeSink {
17
+ /// Wrap a `Html`instance as a sink to drive parsing
18
+ pub fn new(html: Html) -> Self {
19
+ Self(RefCell::new(html))
20
+ }
21
+ }
22
+
23
+ /// Note: does not support the `<template>` element.
24
+ impl TreeSink for HtmlTreeSink {
25
+ type Output = Html;
26
+ type Handle = NodeId;
27
+ type ElemName<'a> = Ref<'a, QualName>;
28
+
29
+ fn finish(self) -> Html {
30
+ self.0.into_inner()
31
+ }
32
+
33
+ // Signal a parse error.
34
+ fn parse_error(&self, msg: Cow<'static, str>) {
35
+ #[cfg(feature = "errors")]
36
+ self.0.borrow_mut().errors.push(msg);
37
+ #[cfg(not(feature = "errors"))]
38
+ let _ = msg;
39
+ }
40
+
41
+ // Set the document's quirks mode.
42
+ fn set_quirks_mode(&self, mode: QuirksMode) {
43
+ self.0.borrow_mut().quirks_mode = mode;
44
+ }
45
+
46
+ // Get a handle to the Document node.
47
+ fn get_document(&self) -> Self::Handle {
48
+ self.0.borrow().tree.root().id()
49
+ }
50
+
51
+ // Do two handles refer to the same node?
52
+ fn same_node(&self, x: &Self::Handle, y: &Self::Handle) -> bool {
53
+ x == y
54
+ }
55
+
56
+ // What is the name of this element?
57
+ //
58
+ // Should never be called on a non-element node; feel free to panic!.
59
+ fn elem_name<'a>(&'a self, target: &Self::Handle) -> Ref<'a, QualName> {
60
+ Ref::map(self.0.borrow(), |this| {
61
+ &this
62
+ .tree
63
+ .get(*target)
64
+ .unwrap()
65
+ .value()
66
+ .as_element()
67
+ .unwrap()
68
+ .name
69
+ })
70
+ }
71
+
72
+ // Create an element.
73
+ //
74
+ // When creating a template element (name.expanded() == expanded_name!(html "template")), an
75
+ // associated document fragment called the "template contents" should also be created. Later
76
+ // calls to self.get_template_contents() with that given element return it.
77
+ fn create_element(
78
+ &self,
79
+ name: QualName,
80
+ attrs: Vec<Attribute>,
81
+ _flags: ElementFlags,
82
+ ) -> Self::Handle {
83
+ let fragment = name.expanded() == expanded_name!(html "template");
84
+
85
+ let mut this = self.0.borrow_mut();
86
+ let mut node = this.tree.orphan(Node::Element(Element::new(name, attrs)));
87
+
88
+ if fragment {
89
+ node.append(Node::Fragment);
90
+ }
91
+
92
+ node.id()
93
+ }
94
+
95
+ // Create a comment node.
96
+ fn create_comment(&self, text: StrTendril) -> Self::Handle {
97
+ self.0
98
+ .borrow_mut()
99
+ .tree
100
+ .orphan(Node::Comment(Comment {
101
+ comment: make_tendril(text),
102
+ }))
103
+ .id()
104
+ }
105
+
106
+ // Append a DOCTYPE element to the Document node.
107
+ fn append_doctype_to_document(
108
+ &self,
109
+ name: StrTendril,
110
+ public_id: StrTendril,
111
+ system_id: StrTendril,
112
+ ) {
113
+ let name = make_tendril(name);
114
+ let public_id = make_tendril(public_id);
115
+ let system_id = make_tendril(system_id);
116
+ let doctype = Doctype {
117
+ name,
118
+ public_id,
119
+ system_id,
120
+ };
121
+ self.0
122
+ .borrow_mut()
123
+ .tree
124
+ .root_mut()
125
+ .append(Node::Doctype(doctype));
126
+ }
127
+
128
+ // Append a node as the last child of the given node. If this would produce adjacent sibling
129
+ // text nodes, it should concatenate the text instead.
130
+ //
131
+ // The child node will not already have a parent.
132
+ fn append(&self, parent: &Self::Handle, child: NodeOrText<Self::Handle>) {
133
+ let mut this = self.0.borrow_mut();
134
+ let mut parent = this.tree.get_mut(*parent).unwrap();
135
+
136
+ match child {
137
+ NodeOrText::AppendNode(id) => {
138
+ parent.append_id(id);
139
+ }
140
+
141
+ NodeOrText::AppendText(text) => {
142
+ let text = make_tendril(text);
143
+
144
+ let did_concat = parent.last_child().is_some_and(|mut n| match n.value() {
145
+ Node::Text(t) => {
146
+ t.text.push_tendril(&text);
147
+ true
148
+ }
149
+ _ => false,
150
+ });
151
+
152
+ if !did_concat {
153
+ parent.append(Node::Text(Text { text }));
154
+ }
155
+ }
156
+ }
157
+ }
158
+
159
+ // Append a node as the sibling immediately before the given node. If that node has no parent,
160
+ // do nothing and return Err(new_node).
161
+ //
162
+ // The tree builder promises that sibling is not a text node. However its old previous sibling,
163
+ // which would become the new node's previous sibling, could be a text node. If the new node is
164
+ // also a text node, the two should be merged, as in the behavior of append.
165
+ //
166
+ // NB: new_node may have an old parent, from which it should be removed.
167
+ fn append_before_sibling(&self, sibling: &Self::Handle, new_node: NodeOrText<Self::Handle>) {
168
+ let mut this = self.0.borrow_mut();
169
+
170
+ if let NodeOrText::AppendNode(id) = new_node {
171
+ this.tree.get_mut(id).unwrap().detach();
172
+ }
173
+
174
+ let mut sibling = this.tree.get_mut(*sibling).unwrap();
175
+ if sibling.parent().is_some() {
176
+ match new_node {
177
+ NodeOrText::AppendNode(id) => {
178
+ sibling.insert_id_before(id);
179
+ }
180
+
181
+ NodeOrText::AppendText(text) => {
182
+ let text = make_tendril(text);
183
+
184
+ let did_concat = sibling.prev_sibling().is_some_and(|mut n| match n.value() {
185
+ Node::Text(t) => {
186
+ t.text.push_tendril(&text);
187
+ true
188
+ }
189
+ _ => false,
190
+ });
191
+
192
+ if !did_concat {
193
+ sibling.insert_before(Node::Text(Text { text }));
194
+ }
195
+ }
196
+ }
197
+ }
198
+ }
199
+
200
+ // Detach the given node from its parent.
201
+ fn remove_from_parent(&self, target: &Self::Handle) {
202
+ self.0.borrow_mut().tree.get_mut(*target).unwrap().detach();
203
+ }
204
+
205
+ // Remove all the children from node and append them to new_parent.
206
+ fn reparent_children(&self, node: &Self::Handle, new_parent: &Self::Handle) {
207
+ self.0
208
+ .borrow_mut()
209
+ .tree
210
+ .get_mut(*new_parent)
211
+ .unwrap()
212
+ .reparent_from_id_append(*node);
213
+ }
214
+
215
+ // Add each attribute to the given element, if no attribute with that name already exists. The
216
+ // tree builder promises this will never be called with something else than an element.
217
+ fn add_attrs_if_missing(&self, target: &Self::Handle, attrs: Vec<Attribute>) {
218
+ let mut this = self.0.borrow_mut();
219
+ let mut node = this.tree.get_mut(*target).unwrap();
220
+ let element = match *node.value() {
221
+ Node::Element(ref mut e) => e,
222
+ _ => unreachable!(),
223
+ };
224
+
225
+ for attr in attrs {
226
+ element
227
+ .attrs
228
+ .or_insert(attr.name, make_tendril(attr.value));
229
+ }
230
+ }
231
+
232
+ // Get a handle to a template's template contents.
233
+ //
234
+ // The tree builder promises this will never be called with something else than a template
235
+ // element.
236
+ fn get_template_contents(&self, target: &Self::Handle) -> Self::Handle {
237
+ self.0
238
+ .borrow()
239
+ .tree
240
+ .get(*target)
241
+ .unwrap()
242
+ .first_child()
243
+ .unwrap()
244
+ .id()
245
+ }
246
+
247
+ // Mark a HTML <script> element as "already started".
248
+ fn mark_script_already_started(&self, _node: &Self::Handle) {}
249
+
250
+ // Create Processing Instruction.
251
+ fn create_pi(&self, target: StrTendril, data: StrTendril) -> Self::Handle {
252
+ let target = make_tendril(target);
253
+ let data = make_tendril(data);
254
+ self.0
255
+ .borrow_mut()
256
+ .tree
257
+ .orphan(Node::ProcessingInstruction(ProcessingInstruction {
258
+ target,
259
+ data,
260
+ }))
261
+ .id()
262
+ }
263
+
264
+ fn append_based_on_parent_node(
265
+ &self,
266
+ element: &Self::Handle,
267
+ prev_element: &Self::Handle,
268
+ child: NodeOrText<Self::Handle>,
269
+ ) {
270
+ let has_parent = self
271
+ .0
272
+ .borrow()
273
+ .tree
274
+ .get(*element)
275
+ .unwrap()
276
+ .parent()
277
+ .is_some();
278
+
279
+ if has_parent {
280
+ self.append_before_sibling(element, child)
281
+ } else {
282
+ self.append(prev_element, child)
283
+ }
284
+ }
285
+ }