roxxie-proxy-u-prod 0.1.0

package/source/packages/scramjet/packages/core/rewriter/native/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "native"
+version = "0.1.0"
+edition = "2024"
+
+[lints]
+workspace = true
+
+[dependencies]
+anyhow = "1.0.100"
+bytes = "1.10.1"
+oxc = { workspace = true }
+js = { version = "0.1.0", path = "../js", default-features = false }
+url = "2.5.7"
+urlencoding = "2.1.3"
+clap = { version = "4.5.51", features = ["cargo", "derive"] }
+
+[features]
+debug = ["js/debug"]
+
+[dev-dependencies]
+boa_engine = "0.20.0"

package/source/packages/scramjet/packages/core/rewriter/native/src/main.rs

@@ -0,0 +1,166 @@
+use std::{
+	env,
+	ffi::OsString,
+	fs,
+	path::PathBuf,
+	sync::Arc,
+	time::{Duration, Instant},
+};
+
+use anyhow::{Context, Result};
+use clap::Parser;
+use oxc::{
+	allocator::{Allocator, StringBuilder},
+	diagnostics::NamedSource,
+};
+use rewriter::NativeRewriter;
+
+mod rewriter;
+mod test_runner;
+
+#[derive(Parser)]
+pub struct RewriterOptions {
+	#[clap(long, default_value = "/scrammedjet/")]
+	prefix: String,
+	#[clap(long, default_value = "$wrap")]
+	wrapfn: String,
+	#[clap(long, default_value = "$sj_")]
+	wrappropertybase: String,
+	#[clap(long, default_value = "$prop")]
+	wrappropertyfn: String,
+	#[clap(long, default_value = "$clean")]
+	cleanrestfn: String,
+	#[clap(long, default_value = "$import")]
+	importfn: String,
+	#[clap(long, default_value = "$rewrite")]
+	rewritefn: String,
+	#[clap(long, default_value = "$meta")]
+	metafn: String,
+	#[clap(long, default_value = "$wrapPostMessage")]
+	wrappostmessage: String,
+	#[clap(long, default_value = "$pushsourcemap")]
+	pushsourcemapfn: String,
+
+	#[clap(long, default_value = "$tryset")]
+	trysetfn: String,
+	#[clap(long, default_value = "$temploc")]
+	templocid: String,
+	#[clap(long, default_value = "$tempunused")]
+	tempunusedid: String,
+
+	#[clap(long, default_value = "https://google.com/glorngle/si.js")]
+	base: String,
+	#[clap(long, default_value = "glongle1")]
+	sourcetag: String,
+	#[clap(long, default_value_t = false)]
+	is_module: bool,
+
+	#[clap(long, default_value_t = false)]
+	capture_errors: bool,
+	#[clap(long, default_value_t = false)]
+	do_sourcemaps: bool,
+	#[clap(long, default_value_t = false)]
+	scramitize: bool,
+	#[clap(long, default_value_t = false)]
+	disable_computed_wrap: bool,
+	#[clap(long, default_value_t = false)]
+	destructure_rewrites: bool,
+}
+
+impl Default for RewriterOptions {
+	fn default() -> Self {
+		Self::parse_from(std::iter::empty::<OsString>())
+	}
+}
+
+#[derive(Parser)]
+#[command(version = clap::crate_version!())]
+pub enum Cli {
+	/// Rewrite a file
+	Rewrite {
+		file: PathBuf,
+		#[clap(flatten)]
+		config: RewriterOptions,
+	},
+	/// Rewrite a file multiple times for flamegraphing
+	Bench {
+		file: PathBuf,
+		iterations: u32,
+		#[clap(flatten)]
+		config: RewriterOptions,
+	},
+}
+
+fn main() -> Result<()> {
+	let args = Cli::parse();
+
+	match args {
+		Cli::Rewrite { file, config } => {
+			let mut rewriter = NativeRewriter::new(&config);
+
+			let data = fs::read_to_string(file).context("failed to read file")?;
+
+			let res = rewriter.rewrite(&data, &config)?;
+
+			let source =
+				Arc::new(NamedSource::new(data.clone(), config.base).with_language("javascript"));
+
+			eprintln!(
+				"rewritten:\n",
+			);
+			println!("{}", str::from_utf8(&res.js).context("failed to parse rewritten js")?);
+
+			let unrewritten = NativeRewriter::unrewrite(&res);
+			// println!(
+			//     "unrewritten:\n{}",
+			//              str::from_utf8(&unrewritten).context("failed to parse unrewritten js")?
+			// );
+
+			eprintln!("errors:");
+			for err in res.errors {
+				eprintln!("{}", err.with_source_code(source.clone()));
+			}
+
+			rewriter.reset();
+
+			eprintln!(
+				"unrewritten matches orig: {}",
+				data.as_bytes() == unrewritten.as_slice()
+			);
+		}
+		Cli::Bench {
+			file,
+			iterations,
+			config,
+		} => {
+			let mut rewriter = NativeRewriter::new(&config);
+
+			let data = fs::read_to_string(file).context("failed to read file")?;
+			let mut duration = Duration::from_secs(0);
+
+			let cnt = iterations * 100;
+
+			for x in 1..=cnt {
+				let before = Instant::now();
+				rewriter
+					.rewrite(&data, &config)
+					.context("failed to rewrite")?;
+				let after = Instant::now();
+
+				rewriter.reset();
+
+				duration += after - before;
+
+				if x % 100 == 0 {
+					println!("{x}...");
+				}
+			}
+
+			println!("iterations: {cnt}");
+			println!("total time: {duration:?}");
+			println!("avg time: {:?}", duration / cnt);
+		}
+	}
+
+	Ok(())
+}

package/source/packages/scramjet/packages/core/rewriter/native/src/rewriter.rs

@@ -0,0 +1,161 @@
+use std::{error::Error, str::FromStr};
+
+use anyhow::{Context, Result};
+use bytes::Buf;
+use js::{
+	RewriteResult, Rewriter,
+	cfg::{Config, Flags, UrlRewriter},
+};
+use oxc::allocator::{Allocator, StringBuilder};
+use url::Url;
+use urlencoding::encode;
+
+use crate::RewriterOptions;
+
+struct NativeUrlRewriter;
+
+impl UrlRewriter for NativeUrlRewriter {
+	fn rewrite(
+		&self,
+		_cfg: &Config,
+		flags: &Flags,
+		url: &str,
+		builder: &mut StringBuilder,
+		_module: bool,
+	) -> Result<(), Box<dyn Error + Sync + Send>> {
+		let base = Url::from_str(&flags.base)?;
+		builder.push_str(encode(base.join(url)?.as_str()).as_ref());
+
+		Ok(())
+	}
+}
+
+#[derive(Debug)]
+enum RewriteType<'a> {
+	Insert { pos: u32, size: u32 },
+	Replace { start: u32, end: u32, str: &'a [u8] },
+}
+
+pub struct NativeRewriter {
+	alloc: Allocator,
+
+	rewriter: Rewriter,
+}
+
+impl NativeRewriter {
+	#[allow(dead_code)]
+	pub fn default() -> Self {
+		Self::new(&RewriterOptions::default())
+	}
+
+	pub fn new(_cfg: &RewriterOptions) -> Self {
+		Self {
+			alloc: Allocator::new(),
+
+			rewriter: Rewriter::new()
+		}
+	}
+
+	#[allow(dead_code)]
+	pub fn rewrite_default(&self, data: &str) -> Result<RewriteResult<'_>> {
+		self.rewrite(data, &RewriterOptions::default())
+	}
+
+	pub fn rewrite(&self, data: &str, cfg: &RewriterOptions) -> Result<RewriteResult<'_>> {
+		let rewriter = NativeUrlRewriter;
+		self.rewriter
+			.rewrite(
+				&self.alloc,
+				data,
+				Config {
+					prefix: cfg.prefix.clone(),
+
+					wrapfn: cfg.wrapfn.clone(),
+					wrappropertybase: cfg.wrappropertybase.clone(),
+					wrappropertyfn: cfg.wrappropertyfn.clone(),
+					cleanrestfn: cfg.cleanrestfn.clone(),
+					importfn: cfg.importfn.clone(),
+					rewritefn: cfg.rewritefn.clone(),
+					wrappostmessagefn: cfg.wrappostmessage.clone(),
+					metafn: cfg.metafn.clone(),
+					pushsourcemapfn: cfg.pushsourcemapfn.clone(),
+
+					trysetfn: cfg.trysetfn.clone(),
+					templocid: cfg.templocid.clone(),
+					tempunusedid: cfg.tempunusedid.clone(),
+				},
+				Flags {
+					base: cfg.base.clone(),
+					sourcetag: cfg.sourcetag.clone(),
+					is_module: cfg.is_module,
+
+					capture_errors: cfg.capture_errors,
+					do_sourcemaps: cfg.do_sourcemaps,
+					scramitize: cfg.scramitize,
+					disable_computed_wrap: cfg.disable_computed_wrap,
+					destructure_rewrites: cfg.destructure_rewrites,
+				},
+				&rewriter
+			)
+			.context("failed to rewrite file")
+	}
+	pub fn reset(&mut self) {
+		self.alloc.reset();
+	}
+
+	pub fn unrewrite(res: &RewriteResult) -> Vec<u8> {
+		let js = res.js.as_slice();
+		let mut map = res.sourcemap.as_slice();
+		let rewrite_cnt = map.get_u32_le();
+		let mut rewrites = Vec::with_capacity(rewrite_cnt as usize);
+
+		for x in 0..rewrite_cnt {
+			let pos = map.get_u32_le();
+			let size = map.get_u32_le();
+
+			let ty = map.get_u8();
+			if ty == 0 {
+				rewrites.push(RewriteType::Insert { pos, size });
+			} else if ty == 1 {
+				let len = map.get_u32_le();
+
+				let (str, new) = map.split_at(len as usize);
+				map = new;
+
+				rewrites.push(RewriteType::Replace {
+					start: pos,
+					end: pos + size,
+					str,
+				});
+			} else {
+				panic!(
+					"{x} {ty} {:X?} {:#?}",
+					&map[0..10],
+					&rewrites.last_chunk::<3>()
+				)
+			}
+		}
+
+		let mut out = Vec::with_capacity(res.js.len());
+
+		let mut cursor: u32 = 0;
+
+		for rewrite in rewrites {
+			match rewrite {
+				RewriteType::Insert { pos, size } => {
+					out.extend_from_slice(&js[cursor as usize..pos as usize]);
+					cursor = pos + size;
+				}
+				RewriteType::Replace { start, end, str } => {
+					out.extend_from_slice(&js[cursor as usize..start as usize]);
+					out.extend_from_slice(&str);
+					cursor = end;
+				}
+			}
+		}
+
+		out.extend_from_slice(&js[cursor as usize..]);
+
+		out.to_vec()
+	}
+}

package/source/packages/scramjet/packages/core/rewriter/native/src/test_runner.rs

@@ -0,0 +1,156 @@
+#[cfg(test)]
+mod test {
+	use std::fs;
+
+	use crate::{RewriterOptions, rewriter::NativeRewriter};
+	use boa_engine::{
+		Context, NativeFunction, Source, js_str, js_string,
+		object::ObjectInitializer,
+		property::{Attribute, PropertyDescriptorBuilder},
+	};
+
+	fn create_context() -> Context {
+		let mut context = Context::default();
+
+		let window = ObjectInitializer::new(&mut context).build();
+		context
+			.register_global_property(js_str!("window"), window, Attribute::READONLY)
+			.unwrap();
+		let top = ObjectInitializer::new(&mut context).build();
+		context
+			.register_global_property(js_str!("top"), top, Attribute::READONLY)
+			.unwrap();
+		context
+			.global_object()
+			.define_property_or_throw(
+				js_str!("location"),
+				PropertyDescriptorBuilder::new()
+					.get(
+						NativeFunction::from_copy_closure(|_, _, _| Ok(js_str!("location").into()))
+							.to_js_function(context.realm()),
+					)
+					.set(
+						NativeFunction::from_copy_closure(|_, _, _| {
+							panic!("fail: window.location got set")
+						})
+						.to_js_function(context.realm()),
+					)
+					.build(),
+				&mut context,
+			)
+			.unwrap();
+
+		context
+			.register_global_callable(
+				js_string!("fail"),
+				0,
+				NativeFunction::from_copy_closure(|_, _, _| {
+					panic!("fail");
+				}),
+			)
+			.unwrap();
+
+		context
+			.eval(Source::from_bytes(
+				br#"
+const self = window;
+function $wrap(val) {
+	if (val === window || val == "location" || val == top) return "";
+
+    return val;
+}
+
+function $prop(prop) {
+    if (prop === "location" || prop === "top" || prop === "eval") {
+        return "$sj_"+prop
+    }
+    return prop
+}
+
+const $gwrap = $wrap;
+
+function $scramitize(val) { return val }
+
+function assert(val) {
+	if (!val) fail();
+}
+
+function $tryset(target, op, value) {
+    if (target == "location") return true;
+    return false;
+}
+function $clean() {
+
+}
+
+function check(val) {
+    if (val === window || val === top || val === "location") fail();
+}
+			    "#,
+			))
+			.unwrap();
+
+		context
+	}
+
+	#[test]
+	fn google() {
+		let source_text = include_str!("../sample/google.js");
+
+		let rewriter = NativeRewriter::default();
+		rewriter.rewrite_default(source_text).unwrap();
+	}
+
+	#[test]
+	fn rewrite_tests() {
+		let files = fs::read_dir("./tests").unwrap();
+
+		let opts = RewriterOptions {
+			prefix: String::from("/scrammedjet/"),
+			wrapfn: String::from("$wrap"),
+			wrappropertybase: String::from("$sj_"),
+			wrappropertyfn: String::from("$prop"),
+			cleanrestfn: String::from("$clean"),
+			importfn: String::from("$import"),
+			rewritefn: String::from("$rewrite"),
+			metafn: String::from("$meta"),
+			wrappostmessage: String::from("$wrapPostMessage"),
+			pushsourcemapfn: String::from("$pushsourcemap"),
+			trysetfn: String::from("$tryset"),
+			templocid: String::from("$temploc"),
+			tempunusedid: String::from("$tempunused"),
+
+			base: String::from("https://google.com/glorngle/si.js"),
+			sourcetag: String::from("glongle1"),
+			is_module: false,
+
+			capture_errors: false,
+			do_sourcemaps: false,
+			scramitize: false,
+			disable_computed_wrap: false,
+			destructure_rewrites: true,
+		};
+
+		let mut rewriter = NativeRewriter::new(&opts);
+
+		for file in files.map(|x| x.unwrap()) {
+			if !file.path().extension().unwrap().eq_ignore_ascii_case("js") {
+				continue;
+			}
+
+			let content = fs::read_to_string(file.path()).unwrap();
+
+			let rewritten = rewriter.rewrite(&content, &opts).unwrap();
+			println!("{}", std::str::from_utf8(&rewritten.js).unwrap());
+
+			let mut ctx = create_context();
+
+			ctx.eval(Source::from_bytes(rewritten.js.as_slice()))
+				.unwrap();
+
+			println!("PASS");
+
+			rewriter.reset();
+		}
+	}
+}

package/source/packages/scramjet/packages/core/rewriter/rust-toolchain.toml

@@ -0,0 +1,5 @@
+[toolchain]
+channel = "nightly"
+targets = ["wasm32-unknown-unknown"]
+components = ["rust-src"]
+

package/source/packages/scramjet/packages/core/rewriter/rustfmt.toml

@@ -0,0 +1,2 @@
+imports_granularity = "Crate"
+hard_tabs = true

package/source/packages/scramjet/packages/core/rewriter/transform/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "transform"
+version = "0.1.0"
+edition = "2024"
+
+[lints]
+workspace = true
+
+[dependencies]
+oxc = { workspace = true }
+itoa = "1.0.15"
+smallvec = "1.15.1"
+thiserror = "2.0.17"
+
+[features]
+debug = []