roxxie-proxy-u-prod 0.1.0

package/source/packages/scramjet/packages/core/rewriter/transform/src/lib.rs

@@ -0,0 +1,242 @@
+use std::{fmt::Display, marker::PhantomData};
+
+use oxc::{
+	allocator::{Allocator, Vec},
+	span::Span,
+};
+use thiserror::Error;
+
+pub mod transform;
+use transform::{Transform, TransformType};
+
+#[derive(Debug, Error)]
+pub enum TransformError {
+	#[cfg(not(feature = "debug"))]
+	#[error("out of bounds while applying range {0}..{1} for {2} (span {3}..{4})")]
+	Oob(u32, u32, &'static str, u32, u32),
+	#[cfg(feature = "debug")]
+	#[error(
+		"out of bounds while applying range {0}..{1} for {2} (span {3}..{4}, last few spans: {5})"
+	)]
+	Oob(u32, u32, &'static str, u32, u32, LastSpans),
+
+	#[cfg(feature = "debug")]
+	#[error("Spans inside each other, all spans: {0}")]
+	InvalidSpans(LastSpans),
+
+	#[error("too much code added while applying changes at cursor {0}")]
+	AddedTooLarge(u32),
+	#[error("Allocator already set")]
+	AllocSet,
+	#[error("Allocator not set")]
+	AllocUnset,
+}
+
+#[cfg(feature = "debug")]
+#[derive(Debug)]
+pub struct LastSpans(std::vec::Vec<(Span, std::string::String)>);
+#[cfg(feature = "debug")]
+impl Display for LastSpans {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f, "\n(current) ")?;
+		for span in &self.0 {
+			writeln!(f, "{}..{}: {}", span.0.start, span.0.end, span.1)?;
+		}
+
+		Ok(())
+	}
+}
+
+pub struct TransformResult<'alloc> {
+	pub source: Vec<'alloc, u8>,
+	pub map: Vec<'alloc, u8>,
+}
+
+pub struct Transformer<'alloc, 'data, T: Transform<'data>> {
+	phantom: PhantomData<&'data str>,
+	alloc: Option<&'alloc Allocator>,
+	inner: std::vec::Vec<T>,
+}
+
+impl<'data, T: Transform<'data>> Default for Transformer<'_, 'data, T> {
+	fn default() -> Self {
+		Self::new()
+	}
+}
+
+impl<'alloc, 'data, T: Transform<'data>> Transformer<'alloc, 'data, T> {
+	pub fn new() -> Self {
+		Self {
+			phantom: PhantomData,
+			inner: std::vec::Vec::new(),
+			alloc: None,
+		}
+	}
+
+	pub fn add(&mut self, rewrite: impl IntoIterator<Item = T>) {
+		self.inner.extend(rewrite);
+	}
+
+	pub fn set_alloc(&mut self, alloc: &'alloc Allocator) -> Result<(), TransformError> {
+		if self.alloc.is_some() {
+			Err(TransformError::AllocSet)
+		} else {
+			self.alloc.replace(alloc);
+			Ok(())
+		}
+	}
+
+	pub fn take_alloc(&mut self) -> Result<(), TransformError> {
+		self.alloc
+			.take()
+			.ok_or(TransformError::AllocUnset)
+			.map(|_| ())
+	}
+
+	pub fn get_alloc(&self) -> Result<&'alloc Allocator, TransformError> {
+		self.alloc.ok_or(TransformError::AllocUnset)
+	}
+
+	pub fn empty(&self) -> bool {
+		self.inner.is_empty()
+	}
+
+	pub fn perform(
+		&mut self,
+		js: &'data str,
+		data: &T::ToLowLevelData,
+		build_map: bool,
+	) -> Result<TransformResult<'alloc>, TransformError> {
+		let mut itoa = itoa::Buffer::new();
+
+		let alloc = self.get_alloc()?;
+
+		let mut cursor = 0;
+		let mut offset = 0i32;
+		let mut buffer = Vec::with_capacity_in(js.len() * 2, alloc);
+
+		#[cfg(feature = "debug")]
+		let mut debug_vec = std::vec::Vec::new();
+
+		macro_rules! tryget {
+			($reason:literal, $start:ident..$end:ident, $span:ident) => {{
+				let ret = js.get($start as usize..$end as usize);
+				#[cfg(not(feature = "debug"))]
+				{
+					ret.ok_or_else(|| {
+						TransformError::Oob($start, $end, $reason, $span.start, $span.end)
+					})?
+				}
+				#[cfg(feature = "debug")]
+				{
+					ret.ok_or_else(|| {
+						TransformError::Oob(
+							$start,
+							$end,
+							$reason,
+							$span.start,
+							$span.end,
+							LastSpans(debug_vec.iter().rev().cloned().take(6).collect()),
+						)
+					})?
+				}
+			}};
+		}
+
+		// insert has a 9 byte size, replace has a 13 byte minimum and usually it's like 5 bytes
+		// for the old str added on so use 16 as a really rough estimate
+		let mut map = if build_map {
+			let mut map = Vec::with_capacity_in((self.inner.len() * 16) + 4, alloc);
+			map.extend_from_slice(&(self.inner.len() as u32).to_le_bytes());
+			map
+		} else {
+			Vec::new_in(alloc)
+		};
+
+		self.inner.sort();
+
+		#[cfg(feature = "debug")]
+		{
+			let mut last_end = 0;
+			for change in &self.inner {
+				let span = change.span();
+				if last_end > span.start {
+					let vec = self
+						.inner
+						.drain(..)
+						.map(|x| {
+							(
+								x.span(),
+								x.into_low_level(data, 0).to_string(&mut itoa, alloc),
+							)
+						})
+						.collect();
+					return Err(TransformError::InvalidSpans(LastSpans(vec)));
+				}
+				last_end = span.end;
+			}
+		}
+
+		for change in self.inner.drain(..) {
+			let span = change.span();
+			let Span { start, end, .. } = span;
+
+			let transform = change.into_low_level(data, offset);
+			#[cfg(feature = "debug")]
+			debug_vec.push((span, transform.to_string(&mut itoa, alloc)));
+
+			buffer.extend_from_slice(tryget!("cursor -> start", cursor..start, span).as_bytes());
+
+			let len = transform.apply(&mut itoa, &mut buffer);
+			if build_map {
+				// pos
+				map.extend_from_slice(&start.wrapping_add_signed(offset).to_le_bytes());
+				// size
+				map.extend_from_slice(&len.to_le_bytes());
+			}
+
+			match transform.ty {
+				TransformType::Insert => {
+					buffer.extend_from_slice(
+						tryget!("insert: start -> end", start..end, span).as_bytes(),
+					);
+
+					if build_map {
+						// INSERT op
+						map.push(0);
+					}
+
+					offset = offset.wrapping_add_unsigned(len);
+				}
+				TransformType::Replace => {
+					if build_map {
+						// REPLACE op
+						map.push(1);
+						// len
+						map.extend_from_slice(&(end - start).to_le_bytes());
+						// oldstr
+						map.extend_from_slice(
+							tryget!("replace: start -> end", start..end, span).as_bytes(),
+						);
+					}
+
+					let len =
+						i32::try_from(len).map_err(|_| TransformError::AddedTooLarge(cursor))?;
+					let diff = len.wrapping_sub_unsigned(end - start);
+					offset = offset.wrapping_add(diff);
+				}
+			}
+
+			cursor = end;
+		}
+
+		let js_len = js.len() as u32;
+		let span = Span::new(0, js_len);
+		buffer.extend_from_slice(tryget!("cursor -> js end", cursor..js_len, span).as_bytes());
+
+		Ok(TransformResult {
+			source: buffer,
+			map,
+		})
+	}
+}

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

@@ -0,0 +1,123 @@
+use oxc::{
+	allocator::{Allocator, Vec},
+	ast::ast::AssignmentOperator,
+	span::{Atom, Span},
+};
+use smallvec::SmallVec;
+
+pub use smallvec as vecimpl;
+
+pub enum TransformElement<'a> {
+	Str(&'a str),
+	U32(u32),
+}
+
+impl TransformElement<'_> {
+	fn eval(&self, itoa: &mut itoa::Buffer, buffer: &mut Vec<'_, u8>) -> usize {
+		match self {
+			TransformElement::Str(x) => {
+				buffer.extend_from_slice(x.as_bytes());
+				x.len()
+			}
+			TransformElement::U32(x) => {
+				let x = itoa.format(*x);
+				buffer.extend_from_slice(x.as_bytes());
+				x.len()
+			}
+		}
+	}
+}
+
+impl<'a> From<&'a str> for TransformElement<'a> {
+	fn from(value: &'a str) -> Self {
+		Self::Str(value)
+	}
+}
+
+impl<'a> From<&&'a str> for TransformElement<'a> {
+	fn from(value: &&'a str) -> Self {
+		Self::Str(value)
+	}
+}
+
+impl<'a> From<&'a String> for TransformElement<'a> {
+	fn from(value: &'a String) -> Self {
+		Self::Str(value)
+	}
+}
+
+impl<'a> From<Atom<'a>> for TransformElement<'a> {
+	fn from(value: Atom<'a>) -> Self {
+		Self::Str(value.as_str())
+	}
+}
+
+impl From<AssignmentOperator> for TransformElement<'static> {
+	fn from(value: AssignmentOperator) -> Self {
+		Self::Str(value.as_str())
+	}
+}
+
+impl From<u32> for TransformElement<'static> {
+	fn from(value: u32) -> Self {
+		Self::U32(value)
+	}
+}
+
+pub type TransformElements<'a> = SmallVec<[TransformElement<'a>; 8]>;
+
+pub enum TransformType {
+	Insert,
+	Replace,
+}
+
+pub trait Transform<'a>: Ord {
+	type ToLowLevelData: 'a;
+
+	fn span(&self) -> Span;
+	fn into_low_level(self, data: &Self::ToLowLevelData, offset: i32) -> TransformLL<'a>;
+}
+
+pub struct TransformLL<'a> {
+	pub ty: TransformType,
+	pub change: TransformElements<'a>,
+}
+
+impl<'a> TransformLL<'a> {
+	pub fn insert(change: TransformElements<'a>) -> Self {
+		Self {
+			ty: TransformType::Insert,
+			change,
+		}
+	}
+
+	pub fn replace(change: TransformElements<'a>) -> Self {
+		Self {
+			ty: TransformType::Replace,
+			change,
+		}
+	}
+
+	pub fn apply(&self, itoa: &mut itoa::Buffer, buffer: &mut Vec<'_, u8>) -> u32 {
+		let mut len = 0;
+
+		for str in &self.change {
+			len += str.eval(itoa, buffer) as u32;
+		}
+
+		len
+	}
+	pub fn to_string(&self, itoa: &mut itoa::Buffer, alloc: &Allocator) -> String {
+		let mut vec = Vec::new_in(alloc);
+		self.apply(itoa, &mut vec);
+		std::str::from_utf8(&vec).unwrap().to_string()
+	}
+}
+
+#[macro_export]
+macro_rules! transforms {
+	[] => { $crate::transform::vecimpl::SmallVec::new() };
+	[$($change:expr),+] => {
+		$crate::transform::vecimpl::smallvec![$(transform::transform::TransformElement::from($change)),+]
+    };
+}

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

@@ -0,0 +1,22 @@
+[package]
+name = "wasm"
+version = "0.1.0"
+edition = "2024"
+
+[lints]
+workspace = true
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+js-sys = "0.3.82"
+oxc = { workspace = true }
+js = { version = "0.1.0", path = "../js", default-features = false }
+thiserror = "2.0.17"
+wasm-bindgen = "0.2.105"
+web-sys = { version = "0.3.82", features = ["Url","UrlSearchParams"] }
+
+[features]
+default = ["debug"]
+debug = ["js/debug"]

package/source/packages/scramjet/packages/core/rewriter/wasm/build.sh

@@ -0,0 +1,128 @@
+#!/usr/bin/env bash
+set -euo pipefail
+shopt -s inherit_errexit
+
+
+
+if ! [ "${RELEASE:-0}" = "1" ]; then
+	WASMOPTFLAGS="${WASMOPTFLAGS:-} -g"
+	FEATURES="debug,${FEATURES:-}"
+else
+	: "${WASMOPTFLAGS:=}"
+	: "${FEATURES:=}"
+fi
+
+MODE="release"
+if [ "${RELEASE:-0}" != "1" ]; then MODE="debug"; fi
+# shellcheck disable=SC2046
+SRC_HASH=$( (echo "MODE=${MODE}"; sha256sum $(find ../ -type f -not -path "*/\.*" -and \( -name "*.rs" -o -name "*.toml" -o -name "*.sh" -o -name "*.json" -o -name "*.md" \); echo Cargo.toml; echo build.sh) 2>/dev/null | sort -k2 | sha256sum ) | sha256sum | cut -d' ' -f1 ) || SRC_HASH="unknown"
+
+if [ -f out/.build-hash ] && [ -f ../../dist/scramjet.wasm ] && [ "$SRC_HASH" != "unknown" ] && grep -q "$SRC_HASH" out/.build-hash; then
+  echo "Rewriter sources unchanged (hash $SRC_HASH); skipping rebuild."
+  exit 0
+fi
+
+which cargo wasm-bindgen wasm-opt wasm-snip &> /dev/null || {
+	echo "Please install cargo, wasm-bindgen, wasm-opt from https://github.com/WebAssembly/binaryen, and wasm-snip from https://github.com/r58playz/wasm-snip!"
+	exit 1
+}
+
+WBG="wasm-bindgen 0.2.105"
+if ! [[ "$(wasm-bindgen -V)" =~ ^"$WBG" ]]; then
+	echo "Incorrect wasm-bindgen-cli version: '$(wasm-bindgen -V)' != '$WBG'"
+	exit 1
+fi
+
+(
+	export RUSTFLAGS='-Zlocation-detail=none -Zfmt-debug=none'
+	if [ "${OPTIMIZE_FOR_SIZE:-0}" = "1" ]; then
+		export RUSTFLAGS="${RUSTFLAGS} -C opt-level=z"
+	fi
+	STD_FEATURES=""
+	if [ "${OPTIMIZE_FOR_SPEED:-0}" = "0" ]; then
+		STD_FEATURES="${STD_FEATURES},optimize_for_size"
+	fi
+	cargo +nightly build --release --target wasm32-unknown-unknown \
+		-Z build-std=panic_abort,std -Z build-std-features=${STD_FEATURES} \
+		--no-default-features --features "$FEATURES"
+)
+wasm-bindgen --target web --out-dir out/ ../target/wasm32-unknown-unknown/release/wasm.wasm
+
+if [[ "$OSTYPE" == "darwin"* ]] || [[ "$OSTYPE" == "freebsd"* ]] || [[ "$OSTYPE" == "dragonfly"* ]]; then
+	sed -i '' 's/import.meta.url/""/g' out/wasm.js
+else
+	sed -i 's/import.meta.url/""/g' out/wasm.js
+fi
+
+cd ../../
+
+wasm-snip rewriter/wasm/out/wasm_bg.wasm -o rewriter/wasm/out/wasm_snipped.wasm \
+	-p 'oxc_regular_expression::.*' \
+	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_non_array_type' \
+	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_ts_import_type' \
+	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_type_operator_or_higher' \
+	'oxc_parser::ts::statement::<impl oxc_parser::ParserImpl>::parse_ts_interface_declaration' \
+	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_mapped_type' \
+	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_index_signature_declaration' \
+	'oxc_parser::ts::statement::<impl oxc_parser::ParserImpl>::parse_ts_import_equals_declaration' \
+	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_type_or_type_predicate' \
+	'oxc_parser::ts::statement::<impl oxc_parser::ParserImpl>::parse_ts_namespace_or_module_declaration_body' \
+	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_ts_implements_clause' \
+	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_intersection_type_or_higher' \
+	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_ts_type_name' \
+	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_literal_type_node' \
+	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_asserts_type_predicate' \
+	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_tuple_element_type' \
+	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_type_arguments_of_type_reference' \
+	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_ts_call_signature_member' \
+	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::is_start_of_type' \
+	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_this_type_predicate' \
+	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_type_query' \
+	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_type_reference' \
+	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_type_operator' \
+	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_type_literal' \
+	'oxc_parser::ts::statement::<impl oxc_parser::ParserImpl>::is_at_enum_declaration' \
+	'oxc_parser::jsx::<impl oxc_parser::ParserImpl>::parse_jsx_element' \
+	'oxc_parser::jsx::<impl oxc_parser::ParserImpl>::parse_jsx_identifier' \
+	'oxc_parser::jsx::<impl oxc_parser::ParserImpl>::parse_jsx_element_name' \
+	'oxc_parser::jsx::<impl oxc_parser::ParserImpl>::parse_jsx_children' \
+	'oxc_parser::jsx::<impl oxc_parser::ParserImpl>::parse_jsx_fragment' \
+	'oxc_parser::jsx::<impl oxc_parser::ParserImpl>::parse_jsx_expression_container' \
+	'oxc_parser::jsx::<impl oxc_parser::ParserImpl>::parse_jsx_expression'
+#
+#	these are confirmed to break oxc
+#   'oxc_parser::ts::statement::<impl oxc_parser::ParserImpl>::parse_declaration' \
+#	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_ts_type' \
+#	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_type_arguments_in_expression' \
+#	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_ts_type_parameters' \
+#	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_class_element_modifiers' \
+#	'oxc_parser::ts::statement::<impl oxc_parser::ParserImpl>::eat_decorators' \
+#	'oxc_parser::ts::statement::<impl oxc_parser::ParserImpl>::is_nth_at_modifier' \
+#	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::try_parse_type_arguments' \
+#	'oxc_parser::ts::statement::<impl oxc_parser::ParserImpl>::is_at_ts_index_signature_member' \
+#	'oxc_parser::ts::types::<impl oxc_parser::ParserImpl>::parse_ts_return_type_annotation' \
+#	'oxc_parser::ts::statement::<impl oxc_parser::ParserImpl>::parse_ts_type_annotation' \
+
+
+if [ "${RELEASE:-0}" = "1" ]; then
+	(
+		G="--generate-global-effects"
+		# shellcheck disable=SC2086
+		time wasm-opt $WASMOPTFLAGS \
+			rewriter/wasm/out/wasm_snipped.wasm -o rewriter/wasm/out/optimized.wasm \
+			--converge -tnh --vacuum \
+			$G -O4 $G --flatten $G --rereloop $G -O4 $G -O4 $G -O4 \
+			$G -Oz $G --flatten $G --rereloop $G -Oz $G -Oz $G -Oz \
+			$G --code-folding $G --const-hoisting $G --dae $G --flatten $G --merge-locals \
+			$G -O4 $G --flatten $G --rereloop $G -O4 $G -O4 $G -O4 \
+			$G -Oz $G --flatten $G --rereloop $G -Oz $G -Oz $G -Oz
+	)
+else
+	cp rewriter/wasm/out/wasm_snipped.wasm rewriter/wasm/out/optimized.wasm
+fi
+
+mkdir -p dist/
+
+cp rewriter/wasm/out/optimized.wasm dist/scramjet.wasm
+echo "$SRC_HASH" > rewriter/wasm/out/.build-hash || true
+echo "Rewriter Build Complete!"

package/source/packages/scramjet/packages/core/rewriter/wasm/src/error.rs

@@ -0,0 +1,56 @@
+use std::cell::BorrowMutError;
+
+use js::RewriterError as JsRewriterError;
+use js_sys::Error;
+use thiserror::Error;
+use wasm_bindgen::{JsError, JsValue};
+
+#[derive(Debug, Error)]
+pub enum RewriterError {
+	#[error("JS: {0}")]
+	Js(String),
+	#[error("JS Rewriter: {0}")]
+	JsRewriter(#[from] JsRewriterError),
+
+	#[error("str fromutf8 error: {0}")]
+	Str(#[from] std::str::Utf8Error),
+	#[error("reflect set failed: {0}")]
+	ReflectSetFail(String),
+	#[error("Rewriter was already rewriting")]
+	AlreadyRewriting(#[from] BorrowMutError),
+
+	#[error("{0} was not {1}")]
+	Not(&'static str, &'static str),
+}
+
+impl From<JsValue> for RewriterError {
+	fn from(value: JsValue) -> Self {
+		Self::Js(Error::from(value).to_string().into())
+	}
+}
+
+impl From<RewriterError> for JsValue {
+	fn from(value: RewriterError) -> Self {
+		JsError::from(value).into()
+	}
+}
+
+impl RewriterError {
+	pub fn not_str(x: &'static str) -> Self {
+		Self::Not(x, "string")
+	}
+
+	pub fn not_arr(x: &'static str) -> Self {
+		Self::Not(x, "array")
+	}
+
+	pub fn not_fn(x: &'static str) -> Self {
+		Self::Not(x, "function")
+	}
+
+	pub fn not_bool(x: &'static str) -> Self {
+		Self::Not(x, "bool")
+	}
+}
+
+pub type Result<T> = std::result::Result<T, RewriterError>;

package/source/packages/scramjet/packages/core/rewriter/wasm/src/jsr.rs

@@ -0,0 +1,125 @@
+use std::error::Error;
+
+use js::{
+	RewriteResult, Rewriter,
+	cfg::{Config, Flags, UrlRewriter},
+};
+use js_sys::{Function, Object, Uint8Array, encode_uri_component};
+use oxc::allocator::StringBuilder;
+use wasm_bindgen::{JsCast, JsValue, prelude::wasm_bindgen};
+use web_sys::Url;
+
+use crate::{
+	error::{Result, RewriterError},
+	 get_obj, get_str, set_obj,
+};
+
+// slightly modified https://github.com/ungap/random-uuid/blob/main/index.js
+#[wasm_bindgen(inline_js = r#"
+export function scramtag() {
+    return (""+1e10).replace(/[018]/g,
+      c => (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)
+    );
+}
+"#)]
+extern "C" {
+	pub fn scramtag() -> std::string::String;
+}
+
+#[wasm_bindgen(typescript_custom_section)]
+const REWRITER_OUTPUT: &'static str = r#"
+export type JsRewriterOutput = {
+	js: Uint8Array,
+	map: Uint8Array,
+	scramtag: string,
+	errors: string[],
+};
+"#;
+
+#[wasm_bindgen]
+extern "C" {
+	#[wasm_bindgen(typescript_type = "JsRewriterOutput")]
+	pub type JsRewriterOutput;
+}
+
+
+pub struct WasmUrlRewriter(Function);
+
+impl UrlRewriter for WasmUrlRewriter {
+	fn rewrite(
+		&self,
+		_cfg: &Config,
+		flags: &Flags,
+		url: &str,
+		builder: &mut StringBuilder,
+		module: bool,
+	) -> std::result::Result<(), Box<dyn Error + Sync + Send>> {
+		let url = Url::new_with_base(url, &flags.base)
+			.map_err(RewriterError::from)?
+			.to_string();
+
+		let mut rewritten = self
+			.0
+			.call1(&JsValue::NULL, &url.into())
+			.map_err(RewriterError::from)?
+			.as_string()
+			.ok_or_else(|| RewriterError::not_str("url rewriter output"))?;
+
+		if module {
+			// TODO: keep this in sync with QP.isModule or find a way to make this use the real rewriteUrl function
+			let origin = Url::new(&flags.base).map_err(RewriterError::from)?.origin();
+			let encoded_origin: String = encode_uri_component(&origin).into();
+			rewritten.push_str("?%24module=module&%24io=");
+			rewritten.push_str(&encoded_origin);
+		}
+
+		builder.push_str(&rewritten);
+
+		Ok(())
+	}
+}
+
+pub type JsRewriter = Rewriter;
+
+pub fn create_js() -> Result<JsRewriter> {
+	Ok(Rewriter::new())
+}
+
+pub fn get_url_rewriter(func: Object) -> Result<WasmUrlRewriter> {
+	Ok(WasmUrlRewriter(
+		func
+			.dyn_into()
+			.map_err(|_| RewriterError::not_fn("scramjet.codec.encode"))?,
+	))
+}
+
+pub fn create_js_output(out: RewriteResult, url: String, src: String) -> Result<JsRewriterOutput> {
+	let obj = Object::new();
+	set_obj(&obj, "js", &Uint8Array::from(out.js.as_slice()).into())?;
+	set_obj(
+		&obj,
+		"map",
+		&Uint8Array::from(out.sourcemap.as_slice()).into(),
+	)?;
+	set_obj(&obj, "scramtag", &out.flags.sourcetag.into())?;
+
+	#[cfg(feature = "debug")]
+	{
+		let src = std::sync::Arc::new(
+			oxc::diagnostics::NamedSource::new(url, src).with_language("javascript"),
+		);
+		let errs: Vec<_> = out
+			.errors
+			.into_iter()
+			.map(|x| format!("{}", x.with_source_code(src.clone())))
+			.collect();
+		set_obj(&obj, "errors", &errs.into())?;
+	}
+	#[cfg(not(feature = "debug"))]
+	{
+		let _ = (url, src);
+		set_obj(&obj, "errors", &js_sys::Array::new())?;
+	}
+
+	Ok(JsRewriterOutput::from(JsValue::from(obj)))
+}