|
|
use std::{collections::HashMap, error::Error};
|
|
|
|
|
|
use html::{Rewriter, VisitorExternalTool, rule::RewriteRule};
|
|
|
use js_sys::{Array, Function, Object, Uint8Array};
|
|
|
use oxc::allocator::Allocator;
|
|
|
use wasm_bindgen::{JsCast, JsValue, prelude::wasm_bindgen};
|
|
|
|
|
|
use crate::{
|
|
|
error::{Result, RewriterError},
|
|
|
get_obj, set_obj,
|
|
|
};
|
|
|
|
|
|
#[wasm_bindgen(typescript_custom_section)]
|
|
|
const REWRITER_OUTPUT: &'static str = r#"
|
|
|
export type HtmlRewriterOutput = {
|
|
|
html: Uint8Array,
|
|
|
};
|
|
|
"#;
|
|
|
|
|
|
#[wasm_bindgen]
|
|
|
extern "C" {
|
|
|
#[wasm_bindgen(typescript_type = "HtmlRewriterOutput")]
|
|
|
pub type HtmlRewriterOutput;
|
|
|
}
|
|
|
|
|
|
pub type HtmlRewriter = Rewriter<(Object, Object, Function, Function, Function, Function)>;
|
|
|
|
|
|
fn build_rules(
|
|
|
rules: Vec<Object>,
|
|
|
) -> Result<Vec<RewriteRule<(Object, Object, Function, Function, Function, Function)>>> {
|
|
|
rules
|
|
|
.into_iter()
|
|
|
.map(|x| {
|
|
|
let entries = Object::entries(&x)
|
|
|
.to_vec()
|
|
|
.into_iter()
|
|
|
.map(|x| {
|
|
|
let arr = x
|
|
|
.dyn_into::<Array>()
|
|
|
.map_err(|_| RewriterError::not_arr("Object.entries"))?
|
|
|
.to_vec();
|
|
|
|
|
|
Ok((
|
|
|
arr[0]
|
|
|
.as_string()
|
|
|
.ok_or(RewriterError::not_str("Object.entries key"))?,
|
|
|
arr[1].clone(),
|
|
|
))
|
|
|
})
|
|
|
.collect::<Result<Vec<(String, JsValue)>>>()?;
|
|
|
|
|
|
let mut func = None;
|
|
|
let mut attrs = HashMap::new();
|
|
|
|
|
|
for (k, v) in entries {
|
|
|
if k == "fn" {
|
|
|
func = Some(
|
|
|
v.dyn_into::<Function>()
|
|
|
.map_err(|_| RewriterError::not_fn("htmlRules fn"))?,
|
|
|
);
|
|
|
} else if let Ok(v) = v.clone().dyn_into::<Array>() {
|
|
|
let els = v
|
|
|
.to_vec()
|
|
|
.into_iter()
|
|
|
.map(|x| {
|
|
|
x.as_string()
|
|
|
.ok_or(RewriterError::not_str("htmlRules value array value"))
|
|
|
})
|
|
|
.collect::<Result<_>>()?;
|
|
|
|
|
|
attrs.insert(k, Some(els));
|
|
|
} else {
|
|
|
let el = v
|
|
|
.as_string()
|
|
|
.ok_or(RewriterError::not_str("htmlRules value"))?;
|
|
|
|
|
|
if el == "*" {
|
|
|
attrs.insert(k, None);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
Ok(RewriteRule {
|
|
|
attrs,
|
|
|
func: Box::new(
|
|
|
move |alloc,
|
|
|
val,
|
|
|
(meta, cookie, _, _, _, _): &(
|
|
|
Object,
|
|
|
Object,
|
|
|
Function,
|
|
|
Function,
|
|
|
Function,
|
|
|
Function,
|
|
|
)| {
|
|
|
func.as_ref()
|
|
|
.map(|x| {
|
|
|
let ret = x
|
|
|
.call3(&JsValue::NULL, &val.into(), meta, cookie)
|
|
|
.map_err(RewriterError::from)
|
|
|
.map_err(Box::new)?;
|
|
|
|
|
|
Ok(ret.as_string().map(|x| alloc.alloc_str(&x)))
|
|
|
})
|
|
|
.transpose()
|
|
|
.map(Option::flatten)
|
|
|
},
|
|
|
),
|
|
|
})
|
|
|
})
|
|
|
.collect::<Result<_>>()
|
|
|
}
|
|
|
|
|
|
#[wasm_bindgen(inline_js = r#"
|
|
|
export function setMeta(meta, val) {
|
|
|
meta.base = new URL(val, meta.origin);
|
|
|
}
|
|
|
export function base64(bytes) {
|
|
|
const binString = Array.from(bytes, (byte) =>
|
|
|
String.fromCodePoint(byte)
|
|
|
).join("");
|
|
|
|
|
|
return btoa(binString);
|
|
|
}
|
|
|
export function rewriteJsAttr(fn, attr, code, meta) {
|
|
|
return fn(code, `(inline ${attr} on element)`, meta);
|
|
|
}
|
|
|
export function rewriteJsInline(fn, code, module, meta) {
|
|
|
return fn(code, `(inline script element)`, meta, module);
|
|
|
}
|
|
|
export function rewriteCss(fn, code, meta) {
|
|
|
return fn(code, meta);
|
|
|
}
|
|
|
export function rewriteHttpEquiv(fn, content, meta) {
|
|
|
const contentArray = content.split("url=");
|
|
|
if (contentArray[1])
|
|
|
contentArray[1] = fn(contentArray[1].trim(), meta);
|
|
|
return contentArray.join("url=");
|
|
|
}
|
|
|
export function getInjectCode(func, cookie, found_head) {
|
|
|
return func(cookie, found_head);
|
|
|
}
|
|
|
export function log(val) { console.log("aaaaa", val) }
|
|
|
"#)]
|
|
|
extern "C" {
|
|
|
#[wasm_bindgen(js_name = "setMeta")]
|
|
|
fn __external_tool_set_meta(meta: &Object, val: &str);
|
|
|
#[wasm_bindgen(js_name = "base64")]
|
|
|
fn __external_tool_base64(bytes: Uint8Array) -> String;
|
|
|
#[wasm_bindgen(js_name = "rewriteJsAttr")]
|
|
|
fn __external_tool_rewrite_js_attr(
|
|
|
func: &Function,
|
|
|
attr: &str,
|
|
|
code: &str,
|
|
|
meta: &Object,
|
|
|
) -> String;
|
|
|
#[wasm_bindgen(js_name = "rewriteJsInline")]
|
|
|
fn __external_tool_rewrite_js_inline(
|
|
|
func: &Function,
|
|
|
code: &str,
|
|
|
module: bool,
|
|
|
meta: &Object,
|
|
|
) -> String;
|
|
|
#[wasm_bindgen(js_name = "rewriteCss")]
|
|
|
fn __external_tool_rewrite_css(func: &Function, code: &str, meta: &Object) -> String;
|
|
|
#[wasm_bindgen(js_name = "rewriteHttpEquiv")]
|
|
|
fn __external_tool_rewrite_http_equiv(func: &Function, content: &str, meta: &Object) -> String;
|
|
|
#[wasm_bindgen(js_name = "getInjectCode")]
|
|
|
fn __external_tool_get_inject_code(
|
|
|
func: &Function,
|
|
|
cookie: &Object,
|
|
|
found_head: bool,
|
|
|
) -> String;
|
|
|
#[wasm_bindgen(js_name = "log")]
|
|
|
fn __external_tool_log(val: &str);
|
|
|
}
|
|
|
|
|
|
fn external_tool<'alloc, 'data>(
|
|
|
alloc: &'alloc Allocator,
|
|
|
tool: VisitorExternalTool<'data>,
|
|
|
(meta, cookie, rewrite_js, rewrite_css, rewrite_url, get_inject): &'data (
|
|
|
Object,
|
|
|
Object,
|
|
|
Function,
|
|
|
Function,
|
|
|
Function,
|
|
|
Function,
|
|
|
),
|
|
|
) -> std::result::Result<Option<&'alloc str>, Box<dyn Error + Sync + Send>> {
|
|
|
match tool {
|
|
|
VisitorExternalTool::SetMetaBase(val) => {
|
|
|
__external_tool_set_meta(meta, val);
|
|
|
Ok(None)
|
|
|
}
|
|
|
VisitorExternalTool::Base64(val) => Ok(Some(
|
|
|
alloc.alloc_str(&__external_tool_base64(Uint8Array::from(val.as_bytes()))),
|
|
|
)),
|
|
|
VisitorExternalTool::RewriteJsAttr { attr, code } => Ok(Some(alloc.alloc_str(
|
|
|
&__external_tool_rewrite_js_attr(rewrite_js, attr, code, meta),
|
|
|
))),
|
|
|
VisitorExternalTool::RewriteInlineScript { code, module } => Ok(Some(alloc.alloc_str(
|
|
|
&__external_tool_rewrite_js_inline(rewrite_js, code, module, meta),
|
|
|
))),
|
|
|
VisitorExternalTool::RewriteCss(css) => Ok(Some(
|
|
|
alloc.alloc_str(&__external_tool_rewrite_css(rewrite_css, css, meta)),
|
|
|
)),
|
|
|
VisitorExternalTool::RewriteHttpEquivContent(content) => Ok(Some(alloc.alloc_str(
|
|
|
&__external_tool_rewrite_http_equiv(rewrite_url, content, meta),
|
|
|
))),
|
|
|
VisitorExternalTool::Log(log) => {
|
|
|
__external_tool_log(log);
|
|
|
Ok(None)
|
|
|
}
|
|
|
VisitorExternalTool::GetScriptText { found_head } => Ok(Some(alloc.alloc_str(
|
|
|
&__external_tool_get_inject_code(get_inject, cookie, found_head),
|
|
|
))),
|
|
|
}
|
|
|
}
|
|
|
|
|
|
pub fn create_html(scramjet: &Object) -> Result<HtmlRewriter> {
|
|
|
let shared = get_obj(scramjet, "shared")?;
|
|
|
let rewrite = get_obj(&shared, "rewrite")?;
|
|
|
let html_rules = get_obj(&rewrite, "htmlRules")?
|
|
|
.dyn_into::<Array>()
|
|
|
.map_err(|_| RewriterError::not_arr("htmlRules"))?;
|
|
|
let html_rules = html_rules.to_vec().into_iter().map(Object::from).collect();
|
|
|
|
|
|
let rules = build_rules(html_rules)?;
|
|
|
|
|
|
Ok(HtmlRewriter::new(rules, Box::new(external_tool))?)
|
|
|
}
|
|
|
|
|
|
pub fn get_html_params(scramjet: &Object) -> Result<(Function, Function, Function, Function)> {
|
|
|
let shared = get_obj(scramjet, "shared")?;
|
|
|
let rewrite = get_obj(&shared, "rewrite")?;
|
|
|
|
|
|
let js = get_obj(&rewrite, "rewriteJs")?
|
|
|
.dyn_into::<Function>()
|
|
|
.map_err(|_| RewriterError::not_fn("rewriteJs"))?;
|
|
|
let css = get_obj(&rewrite, "rewriteCss")?
|
|
|
.dyn_into::<Function>()
|
|
|
.map_err(|_| RewriterError::not_fn("rewriteCss"))?;
|
|
|
let url = get_obj(&rewrite, "rewriteUrl")?
|
|
|
.dyn_into::<Function>()
|
|
|
.map_err(|_| RewriterError::not_fn("rewriteUrl"))?;
|
|
|
let inject_code = get_obj(&rewrite, "getHtmlInjectCode")?
|
|
|
.dyn_into::<Function>()
|
|
|
.map_err(|_| RewriterError::not_fn("getHtmlInjectCode"))?;
|
|
|
|
|
|
Ok((js, css, url, inject_code))
|
|
|
}
|
|
|
|
|
|
pub fn create_html_output(out: &[u8]) -> Result<HtmlRewriterOutput> {
|
|
|
let obj = Object::new();
|
|
|
set_obj(&obj, "html", &Uint8Array::from(out).into())?;
|
|
|
|
|
|
Ok(HtmlRewriterOutput::from(JsValue::from(obj)))
|
|
|
}
|
|
|
|
