|
|
use std::error::Error;
|
|
|
|
|
|
use oxc::{
|
|
|
allocator::{Allocator, StringBuilder},
|
|
|
span::Span,
|
|
|
};
|
|
|
use tl::{Bytes, HTMLTag, Node, NodeHandle, VDom};
|
|
|
|
|
|
use crate::{
|
|
|
HtmlChanges, RewriterError,
|
|
|
changes::HtmlRewrite,
|
|
|
rule::{RewriteRule, RewriteRuleCallback},
|
|
|
};
|
|
|
|
|
|
const EVENT_ATTRIBUTES: [&str; 100] = [
|
|
|
"onbeforexrselect",
|
|
|
"onabort",
|
|
|
"onbeforeinput",
|
|
|
"onbeforematch",
|
|
|
"onbeforetoggle",
|
|
|
"onblur",
|
|
|
"oncancel",
|
|
|
"oncanplay",
|
|
|
"oncanplaythrough",
|
|
|
"onchange",
|
|
|
"onclick",
|
|
|
"onclose",
|
|
|
"oncontentvisibilityautostatechange",
|
|
|
"oncontextlost",
|
|
|
"oncontextmenu",
|
|
|
"oncontextrestored",
|
|
|
"oncuechange",
|
|
|
"ondblclick",
|
|
|
"ondrag",
|
|
|
"ondragend",
|
|
|
"ondragenter",
|
|
|
"ondragleave",
|
|
|
"ondragover",
|
|
|
"ondragstart",
|
|
|
"ondrop",
|
|
|
"ondurationchange",
|
|
|
"onemptied",
|
|
|
"onended",
|
|
|
"onerror",
|
|
|
"onfocus",
|
|
|
"onformdata",
|
|
|
"oninput",
|
|
|
"oninvalid",
|
|
|
"onkeydown",
|
|
|
"onkeypress",
|
|
|
"onkeyup",
|
|
|
"onload",
|
|
|
"onloadeddata",
|
|
|
"onloadedmetadata",
|
|
|
"onloadstart",
|
|
|
"onmousedown",
|
|
|
"onmouseenter",
|
|
|
"onmouseleave",
|
|
|
"onmousemove",
|
|
|
"onmouseout",
|
|
|
"onmouseover",
|
|
|
"onmouseup",
|
|
|
"onmousewheel",
|
|
|
"onpause",
|
|
|
"onplay",
|
|
|
"onplaying",
|
|
|
"onprogress",
|
|
|
"onratechange",
|
|
|
"onreset",
|
|
|
"onresize",
|
|
|
"onscroll",
|
|
|
"onsecuritypolicyviolation",
|
|
|
"onseeked",
|
|
|
"onseeking",
|
|
|
"onselect",
|
|
|
"onslotchange",
|
|
|
"onstalled",
|
|
|
"onsubmit",
|
|
|
"onsuspend",
|
|
|
"ontimeupdate",
|
|
|
"ontoggle",
|
|
|
"onvolumechange",
|
|
|
"onwaiting",
|
|
|
"onwebkitanimationend",
|
|
|
"onwebkitanimationiteration",
|
|
|
"onwebkitanimationstart",
|
|
|
"onwebkittransitionend",
|
|
|
"onwheel",
|
|
|
"onauxclick",
|
|
|
"ongotpointercapture",
|
|
|
"onlostpointercapture",
|
|
|
"onpointerdown",
|
|
|
"onpointermove",
|
|
|
"onpointerrawupdate",
|
|
|
"onpointerup",
|
|
|
"onpointercancel",
|
|
|
"onpointerover",
|
|
|
"onpointerout",
|
|
|
"onpointerenter",
|
|
|
"onpointerleave",
|
|
|
"onselectstart",
|
|
|
"onselectionchange",
|
|
|
"onanimationend",
|
|
|
"onanimationiteration",
|
|
|
"onanimationstart",
|
|
|
"ontransitionrun",
|
|
|
"ontransitionstart",
|
|
|
"ontransitionend",
|
|
|
"ontransitioncancel",
|
|
|
"oncopy",
|
|
|
"oncut",
|
|
|
"onpaste",
|
|
|
"onscrollend",
|
|
|
"onscrollsnapchange",
|
|
|
"onscrollsnapchanging",
|
|
|
];
|
|
|
|
|
|
pub type VisitorExternalToolCallback<T> = Box<
|
|
|
dyn for<'alloc, 'data> Fn(
|
|
|
&'alloc Allocator,
|
|
|
VisitorExternalTool<'data>,
|
|
|
&'data T,
|
|
|
) -> Result<Option<&'alloc str>, Box<dyn Error + Sync + Send>>,
|
|
|
>;
|
|
|
|
|
|
pub struct Visitor<'alloc: 'data, 'data, T> {
|
|
|
pub alloc: &'alloc Allocator,
|
|
|
pub rules: &'data [RewriteRule<T>],
|
|
|
pub external_tool_func: &'data VisitorExternalToolCallback<T>,
|
|
|
pub rule_data: &'data T,
|
|
|
|
|
|
pub data: &'data str,
|
|
|
pub tree: VDom<'data>,
|
|
|
pub from_top: bool,
|
|
|
}
|
|
|
|
|
|
pub enum VisitorExternalTool<'data> {
|
|
|
SetMetaBase(&'data str),
|
|
|
Base64(&'data str),
|
|
|
RewriteInlineScript { code: &'data str, module: bool },
|
|
|
RewriteJsAttr { attr: &'data str, code: &'data str },
|
|
|
RewriteHttpEquivContent(&'data str),
|
|
|
RewriteCss(&'data str),
|
|
|
GetScriptText { found_head: bool },
|
|
|
Log(&'data str),
|
|
|
}
|
|
|
|
|
|
impl<'alloc, 'data, T> Visitor<'alloc, 'data, T> {
|
|
|
fn boundaries(&self, tag: &HTMLTag<'data>) -> Result<Span, RewriterError> {
|
|
|
let (start, end) = tag.boundaries(self.tree.parser());
|
|
|
let end = end + 1;
|
|
|
Ok(Span::new(start.try_into()?, end.try_into()?))
|
|
|
}
|
|
|
|
|
|
fn calculate_bounds(&self, raw: &Bytes<'data>) -> Result<Span, RewriterError> {
|
|
|
let input = self.data.as_ptr();
|
|
|
let start = raw.as_ptr();
|
|
|
let offset = start as usize - input as usize;
|
|
|
let end = offset + raw.as_bytes().len();
|
|
|
|
|
|
Ok(Span::new(offset.try_into()?, end.try_into()?))
|
|
|
}
|
|
|
|
|
|
fn get(&'data self, handle: NodeHandle) -> &'data Node<'data> {
|
|
|
unsafe { handle.get(self.tree.parser()).unwrap_unchecked() }
|
|
|
}
|
|
|
|
|
|
fn check_rules(&self, name: &str, attr: &str) -> Option<&RewriteRuleCallback<T>> {
|
|
|
self.rules
|
|
|
.iter()
|
|
|
.find(|x| {
|
|
|
x.attrs.get(attr).is_some_and(|x| {
|
|
|
x.as_ref()
|
|
|
.is_none_or(|x| x.contains(name) || x.contains("*"))
|
|
|
})
|
|
|
})
|
|
|
.map(|x| &x.func)
|
|
|
}
|
|
|
|
|
|
fn match_script_type(ty: Option<&str>) -> bool {
|
|
|
ty.is_none_or(|x| {
|
|
|
matches!(
|
|
|
x,
|
|
|
"application/javascript" | "text/javascript" | "module" | "importmap",
|
|
|
)
|
|
|
})
|
|
|
}
|
|
|
|
|
|
fn external_tool(
|
|
|
&self,
|
|
|
tool: VisitorExternalTool<'data>,
|
|
|
) -> Result<Option<&'alloc str>, RewriterError> {
|
|
|
(self.external_tool_func)(self.alloc, tool, self.rule_data)
|
|
|
.map_err(RewriterError::ExternalTool)
|
|
|
}
|
|
|
|
|
|
fn external_tool_val(
|
|
|
&self,
|
|
|
tool: VisitorExternalTool<'data>,
|
|
|
) -> Result<&'alloc str, RewriterError> {
|
|
|
self.external_tool(tool)?
|
|
|
.ok_or(RewriterError::ExternalToolEmpty)
|
|
|
}
|
|
|
|
|
|
#[expect(clippy::too_many_lines)]
|
|
|
pub fn rewrite(
|
|
|
&'data self,
|
|
|
changes: &mut HtmlChanges<'alloc, 'data>,
|
|
|
) -> Result<(), RewriterError> {
|
|
|
let mut head = None;
|
|
|
|
|
|
for node in self.tree.nodes() {
|
|
|
if let Node::Tag(tag) = node {
|
|
|
let name = tag.name().try_as_utf8_str().ok_or(RewriterError::NotUtf8)?;
|
|
|
|
|
|
if name == "head" && head.is_none() {
|
|
|
head.replace(tag);
|
|
|
}
|
|
|
|
|
|
if name == "base"
|
|
|
&& let Some(Some(val)) = tag.attributes().get(&"href".into())
|
|
|
{
|
|
|
self.external_tool(VisitorExternalTool::SetMetaBase(
|
|
|
val.try_as_utf8_str().ok_or(RewriterError::NotUtf8)?,
|
|
|
))?;
|
|
|
}
|
|
|
|
|
|
for (k, v) in tag.attributes().iter() {
|
|
|
let attr = k.try_as_utf8_str().ok_or(RewriterError::NotUtf8)?;
|
|
|
|
|
|
if let Some(cb) = self.check_rules(name, attr)
|
|
|
&& let Some(v) = v
|
|
|
{
|
|
|
let value = v.try_as_utf8_str().ok_or(RewriterError::NotUtf8)?;
|
|
|
let change = (cb)(self.alloc, value, self.rule_data)
|
|
|
.map_err(RewriterError::Rewrite)?;
|
|
|
|
|
|
let bounds = self.calculate_bounds(v)?;
|
|
|
|
|
|
if let Some(change) = change {
|
|
|
let change = if name == "script"
|
|
|
&& attr == "src" && let Some(Some(ty)) =
|
|
|
tag.attributes().get(&"type".into())
|
|
|
&& ty.try_as_utf8_str().ok_or(RewriterError::NotUtf8)? == "module"
|
|
|
{
|
|
|
self.alloc.alloc_concat_strs_array([change, "?type=module"])
|
|
|
} else {
|
|
|
change
|
|
|
};
|
|
|
|
|
|
changes.add(HtmlRewrite::replace_attr(bounds, change));
|
|
|
} else {
|
|
|
let key = self.calculate_bounds(k)?;
|
|
|
changes.add(HtmlRewrite::remove_attr(self.data, key, bounds));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if EVENT_ATTRIBUTES.contains(&attr)
|
|
|
&& let Some(v) = v
|
|
|
{
|
|
|
let value = v.try_as_utf8_str().ok_or(RewriterError::NotUtf8)?;
|
|
|
let bounds = self.calculate_bounds(v)?;
|
|
|
let rewritten =
|
|
|
self.external_tool_val(VisitorExternalTool::RewriteJsAttr {
|
|
|
attr,
|
|
|
code: value,
|
|
|
})?;
|
|
|
|
|
|
changes.add(HtmlRewrite::replace_attr(bounds, rewritten));
|
|
|
changes.add(HtmlRewrite::add_scram_attr(bounds, attr, value));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if name == "style"
|
|
|
&& let Some(child) = tag.children().top().get(0)
|
|
|
&& let Node::Raw(child) = self.get(*child)
|
|
|
{
|
|
|
let rewritten = self.external_tool_val(VisitorExternalTool::RewriteCss(
|
|
|
child.try_as_utf8_str().ok_or(RewriterError::NotUtf8)?,
|
|
|
))?;
|
|
|
|
|
|
changes.add(HtmlRewrite::replace(
|
|
|
self.calculate_bounds(child)?,
|
|
|
rewritten,
|
|
|
));
|
|
|
}
|
|
|
|
|
|
if name == "script"
|
|
|
&& let ty = tag
|
|
|
.attributes()
|
|
|
.get(&"type".into())
|
|
|
.and_then(|x| x.as_ref())
|
|
|
.map(|x| x.try_as_utf8_str().ok_or(RewriterError::NotUtf8))
|
|
|
.transpose()? && Self::match_script_type(ty)
|
|
|
&& tag.attributes().get(&"src".into()).is_none()
|
|
|
{
|
|
|
let child = tag.inner_html();
|
|
|
let code = child.try_as_utf8_str().ok_or(RewriterError::NotUtf8)?;
|
|
|
let module = ty.is_some_and(|x| x == "module");
|
|
|
|
|
|
let b64 = self.external_tool_val(VisitorExternalTool::Base64(code))?;
|
|
|
let rewritten =
|
|
|
self.external_tool_val(VisitorExternalTool::RewriteInlineScript {
|
|
|
code,
|
|
|
module,
|
|
|
})?;
|
|
|
|
|
|
changes.add(HtmlRewrite::add_scram_attr(
|
|
|
self.calculate_bounds(tag.name())?,
|
|
|
"script-source-src",
|
|
|
b64,
|
|
|
));
|
|
|
changes.add(HtmlRewrite::replace(
|
|
|
self.calculate_bounds(child)?,
|
|
|
rewritten,
|
|
|
));
|
|
|
}
|
|
|
|
|
|
if name == "meta"
|
|
|
&& let Some(Some(eqiv)) = tag.attributes().get(&"http-equiv".into())
|
|
|
{
|
|
|
let mut val = StringBuilder::from_str_in(
|
|
|
eqiv.try_as_utf8_str().ok_or(RewriterError::NotUtf8)?,
|
|
|
self.alloc,
|
|
|
);
|
|
|
val.as_mut_str().make_ascii_lowercase();
|
|
|
|
|
|
if val == "content-security-policy" {
|
|
|
changes.add(HtmlRewrite::remove_node(self.boundaries(tag)?));
|
|
|
} else if val == "refresh"
|
|
|
&& let Some(Some(content)) = tag.attributes().get(&"content".into())
|
|
|
{
|
|
|
let val = content.try_as_utf8_str().ok_or(RewriterError::NotUtf8)?;
|
|
|
let rewritten = self
|
|
|
.external_tool_val(VisitorExternalTool::RewriteHttpEquivContent(val))?;
|
|
|
changes.add(HtmlRewrite::replace_attr(
|
|
|
self.calculate_bounds(content)?,
|
|
|
rewritten,
|
|
|
));
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if self.from_top {
|
|
|
let (head_span, head_text) = if let Some(head) = head {
|
|
|
let outer = self.boundaries(head)?;
|
|
|
let inner = self.calculate_bounds(head.inner_html())?;
|
|
|
|
|
|
let start = Span::new(outer.start, inner.start);
|
|
|
let text = self
|
|
|
.external_tool_val(VisitorExternalTool::GetScriptText { found_head: true })?;
|
|
|
(start, text)
|
|
|
} else {
|
|
|
let text = self
|
|
|
.external_tool_val(VisitorExternalTool::GetScriptText { found_head: false })?;
|
|
|
(Span::new(0, 0), text)
|
|
|
};
|
|
|
|
|
|
changes.add(HtmlRewrite::insert_text(head_span, head_text));
|
|
|
}
|
|
|
|
|
|
Ok(())
|
|
|
}
|
|
|
}
|
|
|
|
