const CHUNK_SIZE: usize = 8192;

if let Ok(value) = value.as_str() {

return value.into();

}

value

.encode_wide()

.collect::<Vec<_>>()

.chunks(CHUNK_SIZE)

.map(JsString::from_char_code)

.collect::<Array>()

.join("")

let js_err = vm.try_class("_js", "JSError").ok();

let js_arg = if js_err.is_some_and(|js_err| py_err.fast_isinstance(&js_err)) {

py_err.get_arg(0)

} else {

None

};

let js_arg = js_arg

.as_ref()

.and_then(|x| x.downcast_ref::<js_module::PyJsValue>());

match js_arg {

Some(val) => val.value.clone(),

None => {

let res =

serde_wasm_bindgen::to_value(&exceptions::SerializeException::new(vm, py_err));

match res {

Ok(err_info) => PyError::new(err_info).into(),

Err(_) => {

// Fallback: create a basic JS Error with the exception type and message

let exc_type = py_err.class().name().to_string();

let msg = match py_err.as_object().str(vm) {

Ok(s) => format!("{exc_type}: {s}"),

Err(_) => exc_type,

};

js_sys::Error::new(&msg).into()

}

}

}

}

match js_err.dyn_ref::<js_sys::Error>() {

Some(err) => {

let exc_type = match String::from(err.name()).as_str() {

"TypeError" => vm.ctx.exceptions.type_error,

"ReferenceError" => vm.ctx.exceptions.name_error,

"SyntaxError" => vm.ctx.exceptions.syntax_error,

_ => vm.ctx.exceptions.exception_type,

}

.to_owned();

vm.new_exception_msg(exc_type, String::from(err.message()).into())

}

None => vm.new_exception_msg(

vm.ctx.exceptions.exception_type.to_owned(),

format!("{js_err:?}").into(),

),

}

if let Some(ref wasm_id) = vm.wasm_id

&& py_obj.fast_isinstance(vm.ctx.types.function_type)

{

let wasm_vm = WASMVirtualMachine {

id: wasm_id.clone(),

};

let weak_py_obj = wasm_vm.push_held_rc(py_obj).unwrap().unwrap();

let closure = move |args: Option<Box<[JsValue]>>,

kwargs: Option<Object>|

-> Result<JsValue, JsValue> {

let py_obj = match wasm_vm.assert_valid() {

Ok(_) => weak_py_obj

.upgrade()

.expect("weak_py_obj to be valid if VM is valid"),

Err(err) => {

return Err(err);

}

};

stored_vm_from_wasm(&wasm_vm).interp.enter(move |vm| {

let args = match args {

Some(args) => Vec::from(args)

.into_iter()

.map(|arg| js_to_py(vm, arg))

.collect::<Vec<_>>(),

None => Vec::new(),

};

let mut py_func_args = FuncArgs::from(args);

if let Some(ref kwargs) = kwargs {

for pair in object_entries(kwargs) {

let (key, val) = pair?;

py_func_args

.kwargs

.insert(js_string_to_wtf8(&key.into()), js_to_py(vm, val));

}

}

let result = py_obj.call(py_func_args, vm);

pyresult_to_js_result(vm, result)

})

};

let closure = Closure::wrap(Box::new(closure)

as Box<

dyn FnMut(Option<Box<[JsValue]>>, Option<Object>) -> Result<JsValue, JsValue>,

>);

let func = closure.as_ref().clone();

// stores pretty much nothing, it's fine to leak this because if it gets dropped

// the error message is worse

closure.forget();

return func;

}

// the browser module might not be injected

if vm.try_class("_js", "Promise").is_ok()

&& let Some(py_prom) = py_obj.downcast_ref::<js_module::PyPromise>()

{

return py_prom.as_js(vm).into();

}

if let Ok(bytes) = ArgBytesLike::try_from_borrowed_object(vm, &py_obj) {

return bytes.with_ref(|bytes| unsafe {

// `Uint8Array::view` is an `unsafe fn` because it provides

// a direct view into the WASM linear memory; if you were to allocate

// something with Rust that view would probably become invalid. It's safe

// because we then copy the array using `Uint8Array::slice`.

let view = Uint8Array::view(bytes);

view.slice(0, bytes.len() as u32).into()

});

}

py_serde_to_js(vm, &py_obj).unwrap_or(JsValue::UNDEFINED)

vm: &VirtualMachine,

py_obj: &PyObjectRef,

) -> Result<JsValue, serde_wasm_bindgen::Error> {

if let Some(value) = py_obj.downcast_ref::<PyStr>() {

Ok(wtf8_to_js_string(value.as_wtf8()).into())

} else if let Some(value) = py_obj.downcast_ref::<PyList>() {

let array = Array::new();

for item in value.borrow_vec().iter() {

array.push(&py_serde_to_js(vm, item)?);

}

Ok(array.into())

} else if let Some(value) = py_obj.downcast_ref::<PyTuple>() {

let array = Array::new();

for item in value {

array.push(&py_serde_to_js(vm, item)?);

}

Ok(array.into())

} else if let Some(value) = py_obj.downcast_ref::<PyDict>() {

let map = Map::new();

for (key, value) in value {

map.set(&py_serde_to_js(vm, &key)?, &py_serde_to_js(vm, &value)?);

}

Ok(map.into())

} else {

py_serde::serialize(vm, py_obj, &serde_wasm_bindgen::Serializer::new())

}

Object::entries(obj).values().into_iter().map(|pair| {

pair.map(|pair| {

let key = Reflect::get(&pair, &"0".into()).unwrap();

let val = Reflect::get(&pair, &"1".into()).unwrap();

(key, val)

})

})

result

.map(|value| py_to_js(vm, value))

.map_err(|err| py_err_to_js_err(vm, &err))

if js_val.is_object() {

if let Some(promise) = js_val.dyn_ref::<Promise>() {

// the browser module might not be injected

if vm.try_class("browser", "Promise").is_ok() {

return js_module::PyPromise::new(promise.clone())

.into_ref(&vm.ctx)

.into();

}

}

if Array::is_array(&js_val) {

let js_arr: Array = js_val.into();

let elems = js_arr

.values()

.into_iter()

.map(|val| js_to_py(vm, val.expect("Iteration over array failed")))

.collect();

vm.ctx.new_list(elems).into()

} else if let Some(map) = js_val.dyn_ref::<Map>() {

let dict = vm.ctx.new_dict();

for entry in map.entries() {

let entry = Array::from(&entry.expect("Iteration over map failed"));

let key = js_to_py(vm, entry.get(0));

dict.set_item(&*key, js_to_py(vm, entry.get(1)), vm)

.unwrap();

}

dict.into()

} else if ArrayBuffer::is_view(&js_val) || js_val.is_instance_of::<ArrayBuffer>() {

// unchecked_ref because if it's not an ArrayBuffer it could either be a TypedArray

// or a DataView, but they all have a `buffer` property

let u8_array = js_sys::Uint8Array::new(

&js_val

.dyn_ref::<ArrayBuffer>()

.cloned()

.unwrap_or_else(|| js_val.unchecked_ref::<Uint8Array>().buffer()),

);

let mut vec = vec![0; u8_array.length() as usize];

u8_array.copy_to(&mut vec);

vm.ctx.new_bytes(vec).into()

} else {

let dict = vm.ctx.new_dict();

for pair in object_entries(&Object::from(js_val)) {

let (key, val) = pair.expect("iteration over object to not fail");

let py_val = js_to_py(vm, val);

dict.set_item(&*js_string_to_wtf8(&key.into()), py_val, vm)

.unwrap();

}

dict.into()

}

} else if js_val.is_function() {

let func = js_sys::Function::from(js_val);

vm.new_function(

vm.ctx.intern_str(String::from(func.name())).as_str(),

move |args: FuncArgs, vm: &VirtualMachine| -> PyResult {

let this = Object::new();

for (k, v) in args.kwargs {

Reflect::set(&this, &wtf8_to_js_string(&k).into(), &py_to_js(vm, v))

.expect("property to be settable");

}

let js_args = args

.args

.into_iter()

.map(|v| py_to_js(vm, v))

.collect::<Array>();

func.apply(&this, &js_args)

.map(|val| js_to_py(vm, val))

.map_err(|err| js_err_to_py_err(vm, &err))

},

)

.into()

} else if let Some(err) = js_val.dyn_ref::<js_sys::Error>() {

js_err_to_py_err(vm, err).into()

} else if js_val.is_undefined() {

// Because `JSON.stringify(undefined)` returns undefined

vm.ctx.none()

} else if js_val.is_string() {

vm.ctx.new_str(js_string_to_wtf8(&js_val.into())).into()

} else {

py_serde::deserialize(vm, serde_wasm_bindgen::Deserializer::from(js_val))

.unwrap_or_else(|_| vm.ctx.none())

}

let js_err = SyntaxError::new(&format!("Error parsing Python code: {err}"));

let _ = Reflect::set(

&js_err,

&"row".into(),

&(err.location().unwrap().line.get()).into(),

);

let _ = Reflect::set(

&js_err,

&"col".into(),

&(err.location().unwrap().character_offset.get()).into(),

);

// | ParseErrorType::UnrecognizedToken(Token::Dedent, _)

let can_continue = matches!(

&err,

CompileError::Parse(ParseError {

error: ParseErrorType::Lexical(

LexicalErrorType::Eof | LexicalErrorType::IndentationError

),

..

})

);

let _ = Reflect::set(&js_err, &"canContinue".into(), &can_continue.into());

js_err

fn into_js(self, vm: &VirtualMachine) -> Result<T, JsValue> {

self.map_err(|err| py_err_to_js_err(vm, &err))

}