Start profiling

6 files changed, 914 insertions, 914 deletions

diff --git a/scripts/src/libs/allocate.rs b/scripts/src/libs/allocate.rs
index 7f2825d..c2bb2cf 100644
--- a/scripts/src/libs/allocate.rs
+++ b/scripts/src/libs/allocate.rs
@@ -1,76 +1,76 @@
-use wasmtime::Caller;
-
-use crate::{ScriptManager, WasmScriptState};
-
-use super::{
-	system::{_alloc, _get_memory},
-	LIBRARY_NAME,
-};
-
-fn allocate_zeroed(mut caller: Caller<'_, WasmScriptState>, size: u32, align: u32) -> u32 {
-	let Some((ptr, data)) = _alloc(&mut caller, size, align) else {
-		return 0;
-	};
-
-	data.fill(0);
-	ptr
-}
-
-fn reallocate(
-	mut caller: Caller<'_, WasmScriptState>,
-	ptr: u32,
-	size: u32,
-	new_size: u32,
-	align: u32,
-) -> u32 {
-	if new_size < size {
-		return ptr;
-	}
-
-	let bump_pointer = &mut caller.data_mut().bump_pointer;
-	if *bump_pointer == ptr + size {
-		*bump_pointer = ptr;
-		let Some((new_ptr, _)) = _alloc(&mut caller, new_size, align) else {
-			return 4;
-		};
-		return new_ptr;
-	}
-
-	let (_, original) = _get_memory(&mut caller);
-	let Some(original) = original.get(ptr as usize..(ptr + size) as usize) else {
-		return 4;
-	};
-	let original = original.to_vec();
-
-	let Some((new_ptr, data)) = _alloc(&mut caller, new_size, align) else {
-		return 0;
-	};
-
-	data.get_mut(..size as usize)
-		.unwrap()
-		.clone_from_slice(&original);
-	new_ptr
-}
-
-fn duplicate(mut caller: Caller<'_, WasmScriptState>, ptr: u32, size: u32, align: u32) -> u32 {
-	let (_, original) = _get_memory(&mut caller);
-	let Some(original) = original.get(ptr as usize..(ptr + size) as usize) else {
-		return 4;
-	};
-	let original = original.to_vec();
-
-	let Some((new_ptr, data)) = _alloc(&mut caller, size, align) else {
-		return 0;
-	};
-
-	data.clone_from_slice(&original);
-	new_ptr
-}
-
-pub fn library(manager: &mut ScriptManager) -> Option<()> {
-	manager.add_library_function(LIBRARY_NAME, "calloc", allocate_zeroed)?;
-	manager.add_library_function(LIBRARY_NAME, "realloc", reallocate)?;
-	manager.add_library_function(LIBRARY_NAME, "memdup", duplicate)?;
-
-	Some(())
-}
+use wasmtime::Caller;

+

+use crate::{ScriptManager, WasmScriptState};

+

+use super::{

+	system::{_alloc, _get_memory},

+	LIBRARY_NAME,

+};

+

+fn allocate_zeroed(mut caller: Caller<'_, WasmScriptState>, size: u32, align: u32) -> u32 {

+	let Some((ptr, data)) = _alloc(&mut caller, size, align) else {

+		return 0;

+	};

+

+	data.fill(0);

+	ptr

+}

+

+fn reallocate(

+	mut caller: Caller<'_, WasmScriptState>,

+	ptr: u32,

+	size: u32,

+	new_size: u32,

+	align: u32,

+) -> u32 {

+	if new_size < size {

+		return ptr;

+	}

+

+	let bump_pointer = &mut caller.data_mut().bump_pointer;

+	if *bump_pointer == ptr + size {

+		*bump_pointer = ptr;

+		let Some((new_ptr, _)) = _alloc(&mut caller, new_size, align) else {

+			return 4;

+		};

+		return new_ptr;

+	}

+

+	let (_, original) = _get_memory(&mut caller);

+	let Some(original) = original.get(ptr as usize..(ptr + size) as usize) else {

+		return 4;

+	};

+	let original = original.to_vec();

+

+	let Some((new_ptr, data)) = _alloc(&mut caller, new_size, align) else {

+		return 0;

+	};

+

+	data.get_mut(..size as usize)

+		.unwrap()

+		.clone_from_slice(&original);

+	new_ptr

+}

+

+fn duplicate(mut caller: Caller<'_, WasmScriptState>, ptr: u32, size: u32, align: u32) -> u32 {

+	let (_, original) = _get_memory(&mut caller);

+	let Some(original) = original.get(ptr as usize..(ptr + size) as usize) else {

+		return 4;

+	};

+	let original = original.to_vec();

+

+	let Some((new_ptr, data)) = _alloc(&mut caller, size, align) else {

+		return 0;

+	};

+

+	data.clone_from_slice(&original);

+	new_ptr

+}

+

+pub fn library(manager: &mut ScriptManager) -> Option<()> {

+	manager.add_library_function(LIBRARY_NAME, "calloc", allocate_zeroed)?;

+	manager.add_library_function(LIBRARY_NAME, "realloc", reallocate)?;

+	manager.add_library_function(LIBRARY_NAME, "memdup", duplicate)?;

+

+	Some(())

+}

diff --git a/scripts/src/libs/buffer.rs b/scripts/src/libs/buffer.rs
index b4cee77..0958260 100644
--- a/scripts/src/libs/buffer.rs
+++ b/scripts/src/libs/buffer.rs
@@ -1,182 +1,182 @@
-use wasmtime::Caller;
-
-use crate::{ScriptManager, WasmScriptState};
-
-use super::{system::_get_memory, LIBRARY_NAME};
-
-fn memory_search(mut caller: Caller<'_, WasmScriptState>, ptr: u32, ch: u32, len: u32) -> u32 {
-	let (_, mem_ptr) = _get_memory(&mut caller);
-	let len = len as usize;
-	let ptr = ptr as usize;
-	let ch = ch as u8;
-	if (len + ptr) > mem_ptr.len() {
-		return 4;
-	}
-
-	for i in 0..len {
-		if mem_ptr[ptr + i] == ch {
-			return (ptr + i) as u32;
-		}
-	}
-
-	0
-}
-
-fn memory_search_last(mut caller: Caller<'_, WasmScriptState>, ptr: u32, ch: u32, len: u32) -> u32 {
-	let (_, mem_ptr) = _get_memory(&mut caller);
-	let len = len as usize;
-	let ptr = ptr as usize;
-	let ch = ch as u8;
-	if (len + ptr) > mem_ptr.len() {
-		return 4;
-	}
-
-	for i in 0..len {
-		let index = ptr + len - i - 1;
-		if mem_ptr[index] == ch {
-			return index as u32;
-		}
-	}
-
-	0
-}
-
-fn memory_compare(
-	mut caller: Caller<'_, WasmScriptState>,
-	lhs: u32,
-	rhs: u32,
-	len: u32,
-) -> (u32, u32) {
-	let (_, mem_ptr) = _get_memory(&mut caller);
-	let len = len as usize;
-	let lhs = lhs as usize;
-	let rhs = rhs as usize;
-	if (len + lhs) > mem_ptr.len() || (len + rhs) > mem_ptr.len() {
-		return (4, 0);
-	}
-
-	for i in 0..len {
-		let diff = mem_ptr[lhs + i] - mem_ptr[rhs + i];
-		if diff != 0 {
-			return (0, diff as u32);
-		}
-	}
-
-	(0, 0)
-}
-
-fn memory_fill(mut caller: Caller<'_, WasmScriptState>, dest: u32, ch: u32, len: u32) -> u32 {
-	let (_, mem_ptr) = _get_memory(&mut caller);
-	let len = len as usize;
-	let dest = dest as usize;
-	let ch = ch as u8;
-
-	if (len + dest) > mem_ptr.len() {
-		return 4;
-	}
-
-	for i in 0..len {
-		mem_ptr[dest + i] = ch;
-	}
-
-	0
-}
-
-fn memory_copy(mut caller: Caller<'_, WasmScriptState>, dest: u32, src: u32, len: u32) -> u32 {
-	let (_, mem_ptr) = _get_memory(&mut caller);
-	let len = len as usize;
-	let dest = dest as usize;
-	let src = src as usize;
-	if (len + dest) > mem_ptr.len() || (len + src) > mem_ptr.len() {
-		return 4;
-	}
-
-	// check for overlap
-	if (dest < src && dest + len > src) || (src < dest && src + len > dest) {
-		let src = mem_ptr[src..src + len].to_vec();
-		let dest = &mut mem_ptr[dest..dest + len];
-		dest.clone_from_slice(&src);
-	} else {
-		for i in 0..len {
-			mem_ptr[dest + i] = mem_ptr[src + i];
-		}
-	}
-
-	0
-}
-
-fn memory_copy_until(
-	mut caller: Caller<'_, WasmScriptState>,
-	dest: u32,
-	src: u32,
-	len: u32,
-	delimiter: u32,
-) -> u32 {
-	let (_, mem_ptr) = _get_memory(&mut caller);
-	let len = len as usize;
-	let dest = dest as usize;
-	let src = src as usize;
-	let delimiter = delimiter as u8;
-	if (len + dest) > mem_ptr.len() || (len + src) > mem_ptr.len() {
-		return 4;
-	}
-
-	// check for overlap
-	if (dest < src && dest + len > src) || (src < dest && src + len > dest) {
-		let cloned_src = mem_ptr[src..src + len].to_vec();
-		let dest = &mut mem_ptr[dest..dest + len];
-		for i in 0..len {
-			let ch = cloned_src[i];
-			dest[i] = ch;
-			if ch == delimiter {
-				return (src + i + 1) as u32;
-			}
-		}
-	} else {
-		for i in 0..len {
-			let ch = mem_ptr[src + i];
-			mem_ptr[dest + i] = ch;
-			if ch == delimiter {
-				return (src + i + 1) as u32;
-			}
-		}
-	}
-
-	0
-}
-
-fn memory_concatenate(
-	mut caller: Caller<'_, WasmScriptState>,
-	dest: u32,
-	src: u32,
-	dest_len: u32,
-	src_len: u32,
-) -> u32 {
-	let (_, mem_ptr) = _get_memory(&mut caller);
-	let dest = dest as usize;
-	let src = src as usize;
-	let dest_len = dest_len as usize;
-	let src_len = src_len as usize;
-	if (dest_len + src_len + dest) > mem_ptr.len() || (src_len + src) > mem_ptr.len() {
-		return 4;
-	}
-
-	let src = mem_ptr[src..src + src_len].to_vec();
-	let dest_offset = dest + dest_len;
-	let dest = &mut mem_ptr[dest_offset..dest_offset + src_len];
-	dest.clone_from_slice(&src);
-
-	0
-}
-
-pub fn library(manager: &mut ScriptManager) -> Option<()> {
-	manager.add_library_function(LIBRARY_NAME, "memchr", memory_search)?;
-	manager.add_library_function(LIBRARY_NAME, "memrchr", memory_search_last)?;
-	manager.add_library_function(LIBRARY_NAME, "memcmp", memory_compare)?;
-	manager.add_library_function(LIBRARY_NAME, "memset", memory_fill)?;
-	manager.add_library_function(LIBRARY_NAME, "memcpy", memory_copy)?;
-	manager.add_library_function(LIBRARY_NAME, "memccpy", memory_copy_until)?;
-	manager.add_library_function(LIBRARY_NAME, "memcat", memory_concatenate)?;
-
-	Some(())
-}
+use wasmtime::Caller;

+

+use crate::{ScriptManager, WasmScriptState};

+

+use super::{system::_get_memory, LIBRARY_NAME};

+

+fn memory_search(mut caller: Caller<'_, WasmScriptState>, ptr: u32, ch: u32, len: u32) -> u32 {

+	let (_, mem_ptr) = _get_memory(&mut caller);

+	let len = len as usize;

+	let ptr = ptr as usize;

+	let ch = ch as u8;

+	if (len + ptr) > mem_ptr.len() {

+		return 4;

+	}

+

+	for i in 0..len {

+		if mem_ptr[ptr + i] == ch {

+			return (ptr + i) as u32;

+		}

+	}

+

+	0

+}

+

+fn memory_search_last(mut caller: Caller<'_, WasmScriptState>, ptr: u32, ch: u32, len: u32) -> u32 {

+	let (_, mem_ptr) = _get_memory(&mut caller);

+	let len = len as usize;

+	let ptr = ptr as usize;

+	let ch = ch as u8;

+	if (len + ptr) > mem_ptr.len() {

+		return 4;

+	}

+

+	for i in 0..len {

+		let index = ptr + len - i - 1;

+		if mem_ptr[index] == ch {

+			return index as u32;

+		}

+	}

+

+	0

+}

+

+fn memory_compare(

+	mut caller: Caller<'_, WasmScriptState>,

+	lhs: u32,

+	rhs: u32,

+	len: u32,

+) -> (u32, u32) {

+	let (_, mem_ptr) = _get_memory(&mut caller);

+	let len = len as usize;

+	let lhs = lhs as usize;

+	let rhs = rhs as usize;

+	if (len + lhs) > mem_ptr.len() || (len + rhs) > mem_ptr.len() {

+		return (4, 0);

+	}

+

+	for i in 0..len {

+		let diff = mem_ptr[lhs + i] - mem_ptr[rhs + i];

+		if diff != 0 {

+			return (0, diff as u32);

+		}

+	}

+

+	(0, 0)

+}

+

+fn memory_fill(mut caller: Caller<'_, WasmScriptState>, dest: u32, ch: u32, len: u32) -> u32 {

+	let (_, mem_ptr) = _get_memory(&mut caller);

+	let len = len as usize;

+	let dest = dest as usize;

+	let ch = ch as u8;

+

+	if (len + dest) > mem_ptr.len() {

+		return 4;

+	}

+

+	for i in 0..len {

+		mem_ptr[dest + i] = ch;

+	}

+

+	0

+}

+

+fn memory_copy(mut caller: Caller<'_, WasmScriptState>, dest: u32, src: u32, len: u32) -> u32 {

+	let (_, mem_ptr) = _get_memory(&mut caller);

+	let len = len as usize;

+	let dest = dest as usize;

+	let src = src as usize;

+	if (len + dest) > mem_ptr.len() || (len + src) > mem_ptr.len() {

+		return 4;

+	}

+

+	// check for overlap

+	if (dest < src && dest + len > src) || (src < dest && src + len > dest) {

+		let src = mem_ptr[src..src + len].to_vec();

+		let dest = &mut mem_ptr[dest..dest + len];

+		dest.clone_from_slice(&src);

+	} else {

+		for i in 0..len {

+			mem_ptr[dest + i] = mem_ptr[src + i];

+		}

+	}

+

+	0

+}

+

+fn memory_copy_until(

+	mut caller: Caller<'_, WasmScriptState>,

+	dest: u32,

+	src: u32,

+	len: u32,

+	delimiter: u32,

+) -> u32 {

+	let (_, mem_ptr) = _get_memory(&mut caller);

+	let len = len as usize;

+	let dest = dest as usize;

+	let src = src as usize;

+	let delimiter = delimiter as u8;

+	if (len + dest) > mem_ptr.len() || (len + src) > mem_ptr.len() {

+		return 4;

+	}

+

+	// check for overlap

+	if (dest < src && dest + len > src) || (src < dest && src + len > dest) {

+		let cloned_src = mem_ptr[src..src + len].to_vec();

+		let dest = &mut mem_ptr[dest..dest + len];

+		for i in 0..len {

+			let ch = cloned_src[i];

+			dest[i] = ch;

+			if ch == delimiter {

+				return (src + i + 1) as u32;

+			}

+		}

+	} else {

+		for i in 0..len {

+			let ch = mem_ptr[src + i];

+			mem_ptr[dest + i] = ch;

+			if ch == delimiter {

+				return (src + i + 1) as u32;

+			}

+		}

+	}

+

+	0

+}

+

+fn memory_concatenate(

+	mut caller: Caller<'_, WasmScriptState>,

+	dest: u32,

+	src: u32,

+	dest_len: u32,

+	src_len: u32,

+) -> u32 {

+	let (_, mem_ptr) = _get_memory(&mut caller);

+	let dest = dest as usize;

+	let src = src as usize;

+	let dest_len = dest_len as usize;

+	let src_len = src_len as usize;

+	if (dest_len + src_len + dest) > mem_ptr.len() || (src_len + src) > mem_ptr.len() {

+		return 4;

+	}

+

+	let src = mem_ptr[src..src + src_len].to_vec();

+	let dest_offset = dest + dest_len;

+	let dest = &mut mem_ptr[dest_offset..dest_offset + src_len];

+	dest.clone_from_slice(&src);

+

+	0

+}

+

+pub fn library(manager: &mut ScriptManager) -> Option<()> {

+	manager.add_library_function(LIBRARY_NAME, "memchr", memory_search)?;

+	manager.add_library_function(LIBRARY_NAME, "memrchr", memory_search_last)?;

+	manager.add_library_function(LIBRARY_NAME, "memcmp", memory_compare)?;

+	manager.add_library_function(LIBRARY_NAME, "memset", memory_fill)?;

+	manager.add_library_function(LIBRARY_NAME, "memcpy", memory_copy)?;

+	manager.add_library_function(LIBRARY_NAME, "memccpy", memory_copy_until)?;

+	manager.add_library_function(LIBRARY_NAME, "memcat", memory_concatenate)?;

+

+	Some(())

+}

diff --git a/scripts/src/libs/ctype.rs b/scripts/src/libs/ctype.rs
index ca4f326..1236936 100644
--- a/scripts/src/libs/ctype.rs
+++ b/scripts/src/libs/ctype.rs
@@ -1,85 +1,85 @@
-use crate::{libs::LIBRARY_NAME, ScriptManager};
-
-fn char_is(func: impl Fn(char) -> bool, ch: u32) -> u32 {
-	let Some(ch) = char::from_u32(ch) else {
-		return 0;
-	};
-
-	func(ch) as u32
-}
-
-macro_rules! ctype {
-	(fn $fn_name: ident => $fn: expr;) => {
-		fn $fn_name(ch: u32) -> u32 {
-			char_is($fn, ch)
-		}
-	};
-	(fn $fn_name: ident => $fn: expr; $(fn $fn_name2: ident => $fn2: expr;)*) => {
-		fn $fn_name(ch: u32) -> u32 {
-			char_is($fn, ch)
-		}
-		ctype!($(fn $fn_name2 => $fn2;)*);
-	};
-}
-
-ctype!(
-	fn is_alphanumeric => |ch| ch.is_alphanumeric();
-	fn is_alphabetic => |ch| ch.is_alphabetic();
-	fn is_lowercase => |ch| ch.is_lowercase();
-	fn is_uppercase => |ch| ch.is_uppercase();
-	fn is_control => |ch| ch.is_control();
-	fn is_whitespace => |ch| ch.is_whitespace();
-	fn is_ascii_alphanumeric => |ch| ch.is_ascii_alphanumeric();
-	fn is_ascii_alphabetic => |ch| ch.is_ascii_alphabetic();
-	fn is_ascii_lowercase => |ch| ch.is_ascii_lowercase();
-	fn is_ascii_uppercase => |ch| ch.is_ascii_lowercase();
-	fn is_ascii_digit => |ch| ch.is_ascii_digit();
-	fn is_ascii_hexdigit => |ch| ch.is_ascii_hexdigit();
-	fn is_ascii_control => |ch| ch.is_ascii_control();
-	fn is_ascii_graphical => |ch| ch.is_ascii_graphic();
-	fn is_ascii_whitespace => |ch| ch.is_ascii_whitespace();
-	fn is_ascii_blank => |ch| ch == ' ' || ch == '\t';
-	fn is_ascii_printable => |ch| ch.is_alphanumeric() || ch.is_ascii_punctuation();
-	fn is_ascii_punctuation => |ch| ch.is_ascii_punctuation();
-);
-
-fn to_ascii_lower(ch: u32) -> u32 {
-	let Some(ch) = char::from_u32(ch) else {
-		return ch;
-	};
-
-	ch.to_ascii_lowercase() as u32
-}
-
-fn to_ascii_upper(ch: u32) -> u32 {
-	let Some(ch) = char::from_u32(ch) else {
-		return ch;
-	};
-
-	ch.to_ascii_uppercase() as u32
-}
-
-pub fn library(manager: &mut ScriptManager) -> Option<()> {
-	manager.add_library_function(LIBRARY_NAME, "iswalnum", is_alphanumeric)?;
-	manager.add_library_function(LIBRARY_NAME, "iswalpha", is_alphabetic)?;
-	manager.add_library_function(LIBRARY_NAME, "iswlower", is_lowercase)?;
-	manager.add_library_function(LIBRARY_NAME, "iswupper", is_uppercase)?;
-	manager.add_library_function(LIBRARY_NAME, "iswcntrl", is_control)?;
-	manager.add_library_function(LIBRARY_NAME, "iswspace", is_whitespace)?;
-	manager.add_library_function(LIBRARY_NAME, "isalnum", is_ascii_alphanumeric)?;
-	manager.add_library_function(LIBRARY_NAME, "isalpha", is_ascii_alphabetic)?;
-	manager.add_library_function(LIBRARY_NAME, "islower", is_ascii_lowercase)?;
-	manager.add_library_function(LIBRARY_NAME, "isupper", is_ascii_uppercase)?;
-	manager.add_library_function(LIBRARY_NAME, "isdigit", is_ascii_digit)?;
-	manager.add_library_function(LIBRARY_NAME, "isxdigit", is_ascii_hexdigit)?;
-	manager.add_library_function(LIBRARY_NAME, "iscntrl", is_ascii_control)?;
-	manager.add_library_function(LIBRARY_NAME, "isgraph", is_ascii_graphical)?;
-	manager.add_library_function(LIBRARY_NAME, "isspace", is_ascii_whitespace)?;
-	manager.add_library_function(LIBRARY_NAME, "isblank", is_ascii_blank)?;
-	manager.add_library_function(LIBRARY_NAME, "isprint", is_ascii_printable)?;
-	manager.add_library_function(LIBRARY_NAME, "ispunct", is_ascii_punctuation)?;
-	manager.add_library_function(LIBRARY_NAME, "tolower", to_ascii_lower)?;
-	manager.add_library_function(LIBRARY_NAME, "toupper", to_ascii_upper)?;
-
-	Some(())
-}
+use crate::{libs::LIBRARY_NAME, ScriptManager};

+

+fn char_is(func: impl Fn(char) -> bool, ch: u32) -> u32 {

+	let Some(ch) = char::from_u32(ch) else {

+		return 0;

+	};

+

+	func(ch) as u32

+}

+

+macro_rules! ctype {

+	(fn $fn_name: ident => $fn: expr;) => {

+		fn $fn_name(ch: u32) -> u32 {

+			char_is($fn, ch)

+		}

+	};

+	(fn $fn_name: ident => $fn: expr; $(fn $fn_name2: ident => $fn2: expr;)*) => {

+		fn $fn_name(ch: u32) -> u32 {

+			char_is($fn, ch)

+		}

+		ctype!($(fn $fn_name2 => $fn2;)*);

+	};

+}

+

+ctype!(

+	fn is_alphanumeric => |ch| ch.is_alphanumeric();

+	fn is_alphabetic => |ch| ch.is_alphabetic();

+	fn is_lowercase => |ch| ch.is_lowercase();

+	fn is_uppercase => |ch| ch.is_uppercase();

+	fn is_control => |ch| ch.is_control();

+	fn is_whitespace => |ch| ch.is_whitespace();

+	fn is_ascii_alphanumeric => |ch| ch.is_ascii_alphanumeric();

+	fn is_ascii_alphabetic => |ch| ch.is_ascii_alphabetic();

+	fn is_ascii_lowercase => |ch| ch.is_ascii_lowercase();

+	fn is_ascii_uppercase => |ch| ch.is_ascii_lowercase();

+	fn is_ascii_digit => |ch| ch.is_ascii_digit();

+	fn is_ascii_hexdigit => |ch| ch.is_ascii_hexdigit();

+	fn is_ascii_control => |ch| ch.is_ascii_control();

+	fn is_ascii_graphical => |ch| ch.is_ascii_graphic();

+	fn is_ascii_whitespace => |ch| ch.is_ascii_whitespace();

+	fn is_ascii_blank => |ch| ch == ' ' || ch == '\t';

+	fn is_ascii_printable => |ch| ch.is_alphanumeric() || ch.is_ascii_punctuation();

+	fn is_ascii_punctuation => |ch| ch.is_ascii_punctuation();

+);

+

+fn to_ascii_lower(ch: u32) -> u32 {

+	let Some(ch) = char::from_u32(ch) else {

+		return ch;

+	};

+

+	ch.to_ascii_lowercase() as u32

+}

+

+fn to_ascii_upper(ch: u32) -> u32 {

+	let Some(ch) = char::from_u32(ch) else {

+		return ch;

+	};

+

+	ch.to_ascii_uppercase() as u32

+}

+

+pub fn library(manager: &mut ScriptManager) -> Option<()> {

+	manager.add_library_function(LIBRARY_NAME, "iswalnum", is_alphanumeric)?;

+	manager.add_library_function(LIBRARY_NAME, "iswalpha", is_alphabetic)?;

+	manager.add_library_function(LIBRARY_NAME, "iswlower", is_lowercase)?;

+	manager.add_library_function(LIBRARY_NAME, "iswupper", is_uppercase)?;

+	manager.add_library_function(LIBRARY_NAME, "iswcntrl", is_control)?;

+	manager.add_library_function(LIBRARY_NAME, "iswspace", is_whitespace)?;

+	manager.add_library_function(LIBRARY_NAME, "isalnum", is_ascii_alphanumeric)?;

+	manager.add_library_function(LIBRARY_NAME, "isalpha", is_ascii_alphabetic)?;

+	manager.add_library_function(LIBRARY_NAME, "islower", is_ascii_lowercase)?;

+	manager.add_library_function(LIBRARY_NAME, "isupper", is_ascii_uppercase)?;

+	manager.add_library_function(LIBRARY_NAME, "isdigit", is_ascii_digit)?;

+	manager.add_library_function(LIBRARY_NAME, "isxdigit", is_ascii_hexdigit)?;

+	manager.add_library_function(LIBRARY_NAME, "iscntrl", is_ascii_control)?;

+	manager.add_library_function(LIBRARY_NAME, "isgraph", is_ascii_graphical)?;

+	manager.add_library_function(LIBRARY_NAME, "isspace", is_ascii_whitespace)?;

+	manager.add_library_function(LIBRARY_NAME, "isblank", is_ascii_blank)?;

+	manager.add_library_function(LIBRARY_NAME, "isprint", is_ascii_printable)?;

+	manager.add_library_function(LIBRARY_NAME, "ispunct", is_ascii_punctuation)?;

+	manager.add_library_function(LIBRARY_NAME, "tolower", to_ascii_lower)?;

+	manager.add_library_function(LIBRARY_NAME, "toupper", to_ascii_upper)?;

+

+	Some(())

+}

diff --git a/scripts/src/libs/math.rs b/scripts/src/libs/math.rs
index 4aae3c3..c20f322 100644
--- a/scripts/src/libs/math.rs
+++ b/scripts/src/libs/math.rs
@@ -1,398 +1,398 @@
-use crate::ScriptManager;
-
-use super::LIBRARY_NAME;
-
-fn abs_i32(n: i32) -> i32 {
-	n.abs()
-}
-
-fn abs_i64(n: i64) -> i64 {
-	n.abs()
-}
-
-fn mod_f32(x: f32, y: f32) -> f32 {
-	libm::fmodf(x, y)
-}
-
-fn mod_f64(x: f64, y: f64) -> f64 {
-	libm::fmod(x, y)
-}
-
-fn remainder_f32(x: f32, y: f32) -> f32 {
-	libm::remainderf(x, y)
-}
-
-fn remainder_f64(x: f64, y: f64) -> f64 {
-	libm::remainder(x, y)
-}
-
-fn mul_add_f32(x: f32, y: f32, z: f32) -> f32 {
-	x.mul_add(y, z)
-}
-
-fn mul_add_f64(x: f64, y: f64, z: f64) -> f64 {
-	x.mul_add(y, z)
-}
-
-fn fdim_f32(x: f32, y: f32) -> f32 {
-	libm::fdimf(x, y)
-}
-
-fn fdim_f64(x: f64, y: f64) -> f64 {
-	libm::fdim(x, y)
-}
-
-fn exp_f32(x: f32) -> f32 {
-	x.exp()
-}
-
-fn exp_f64(x: f64) -> f64 {
-	x.exp()
-}
-
-fn exp2_f32(x: f32) -> f32 {
-	x.exp2()
-}
-
-fn exp2_f64(x: f64) -> f64 {
-	x.exp2()
-}
-
-fn expm1_f32(x: f32) -> f32 {
-	x.exp_m1()
-}
-
-fn expm1_f64(x: f64) -> f64 {
-	x.exp_m1()
-}
-
-fn ln_f32(x: f32) -> f32 {
-	x.ln()
-}
-
-fn ln_f64(x: f64) -> f64 {
-	x.ln()
-}
-
-fn log10_f32(x: f32) -> f32 {
-	x.log10()
-}
-
-fn log10_f64(x: f64) -> f64 {
-	x.log10()
-}
-
-fn log2_f32(x: f32) -> f32 {
-	x.log2()
-}
-
-fn log2_f64(x: f64) -> f64 {
-	x.log2()
-}
-
-fn ln1p_f32(x: f32) -> f32 {
-	x.ln_1p()
-}
-
-fn ln1p_f64(x: f64) -> f64 {
-	x.ln_1p()
-}
-
-fn pow_f32(base: f32, exponent: f32) -> f32 {
-	base.powf(exponent)
-}
-
-fn pow_f64(base: f64, exponent: f64) -> f64 {
-	base.powf(exponent)
-}
-
-fn cbrt_f32(x: f32) -> f32 {
-	x.cbrt()
-}
-
-fn cbrt_f64(x: f64) -> f64 {
-	x.cbrt()
-}
-
-fn hypotenuse_f32(x: f32, y: f32) -> f32 {
-	x.hypot(y)
-}
-
-fn hypotenuse_f64(x: f64, y: f64) -> f64 {
-	x.hypot(y)
-}
-
-fn sin_f32(x: f32) -> f32 {
-	x.sin()
-}
-
-fn sin_f64(x: f64) -> f64 {
-	x.sin()
-}
-
-fn cos_f32(x: f32) -> f32 {
-	x.cos()
-}
-
-fn cos_f64(x: f64) -> f64 {
-	x.cos()
-}
-
-fn tan_f32(x: f32) -> f32 {
-	x.tan()
-}
-
-fn tan_f64(x: f64) -> f64 {
-	x.tan()
-}
-
-fn asin_f32(x: f32) -> f32 {
-	x.asin()
-}
-
-fn asin_f64(x: f64) -> f64 {
-	x.asin()
-}
-
-fn acos_f32(x: f32) -> f32 {
-	x.acos()
-}
-
-fn acos_f64(x: f64) -> f64 {
-	x.acos()
-}
-
-fn atan_f32(x: f32) -> f32 {
-	x.atan()
-}
-
-fn atan_f64(x: f64) -> f64 {
-	x.atan()
-}
-
-fn sinh_f32(x: f32) -> f32 {
-	x.sinh()
-}
-
-fn sinh_f64(x: f64) -> f64 {
-	x.sinh()
-}
-
-fn cosh_f32(x: f32) -> f32 {
-	x.cosh()
-}
-
-fn cosh_f64(x: f64) -> f64 {
-	x.cosh()
-}
-
-fn tanh_f32(x: f32) -> f32 {
-	x.tanh()
-}
-
-fn tanh_f64(x: f64) -> f64 {
-	x.tanh()
-}
-
-fn asinh_f32(x: f32) -> f32 {
-	x.asinh()
-}
-
-fn asinh_f64(x: f64) -> f64 {
-	x.asinh()
-}
-
-fn acosh_f32(x: f32) -> f32 {
-	x.acosh()
-}
-
-fn acosh_f64(x: f64) -> f64 {
-	x.acosh()
-}
-
-fn atanh_f32(x: f32) -> f32 {
-	x.atanh()
-}
-
-fn atanh_f64(x: f64) -> f64 {
-	x.atanh()
-}
-
-fn erf_f32(x: f32) -> f32 {
-	libm::erff(x)
-}
-
-fn erf_f64(x: f64) -> f64 {
-	libm::erf(x)
-}
-
-fn erfc_f32(x: f32) -> f32 {
-	libm::erfcf(x)
-}
-
-fn erfc_f64(x: f64) -> f64 {
-	libm::erfc(x)
-}
-
-fn gamma_f32(x: f32) -> f32 {
-	libm::tgammaf(x)
-}
-
-fn gamma_f64(x: f64) -> f64 {
-	libm::tgamma(x)
-}
-
-fn ln_gamma_f32(x: f32) -> f32 {
-	libm::lgammaf(x)
-}
-
-fn ln_gamma_f64(x: f64) -> f64 {
-	libm::lgamma(x)
-}
-
-fn round_f32_i32(x: f32) -> i32 {
-	x.round() as i32
-}
-
-fn round_f64_i32(x: f64) -> i32 {
-	x.round() as i32
-}
-
-fn round_f32_i64(x: f32) -> i64 {
-	x.round() as i64
-}
-
-fn round_f64_i64(x: f64) -> i64 {
-	x.round() as i64
-}
-
-fn frexp_f32(x: f32) -> (f32, i32) {
-	libm::frexpf(x)
-}
-
-fn frexp_f64(x: f64) -> (f64, i32) {
-	libm::frexp(x)
-}
-
-fn ldexp_f32(x: f32, exp: i32) -> f32 {
-	libm::ldexpf(x, exp)
-}
-
-fn ldexp_f64(x: f64, exp: i32) -> f64 {
-	libm::ldexp(x, exp)
-}
-
-fn modf_f32(x: f32) -> (f32, f32) {
-	libm::modff(x)
-}
-
-fn modf_f64(x: f64) -> (f64, f64) {
-	libm::modf(x)
-}
-
-fn logb_f32(x: f32) -> i32 {
-	libm::ilogbf(x)
-}
-
-fn logb_f64(x: f64) -> i32 {
-	libm::ilogb(x)
-}
-
-fn next_after_f32(from: f32, to: f32) -> f32 {
-	libm::nextafterf(from, to)
-}
-
-fn next_after_f64(from: f64, to: f64) -> f64 {
-	libm::nextafter(from, to)
-}
-
-fn copy_sign_f32(x: f32, y: f32) -> f32 {
-	libm::copysignf(x, y)
-}
-
-fn copy_sign_f64(x: f64, y: f64) -> f64 {
-	libm::copysign(x, y)
-}
-
-pub fn library(manager: &mut ScriptManager) -> Option<()> {
-	manager.add_library_function(LIBRARY_NAME, "abs", abs_i32)?;
-	manager.add_library_function(LIBRARY_NAME, "labs", abs_i64)?;
-	manager.add_library_function(LIBRARY_NAME, "modf", mod_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "mod", mod_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "remf", remainder_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "rem", remainder_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "fmaf", mul_add_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "fma", mul_add_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "fdimf", fdim_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "fdim", fdim_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "expf", exp_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "exp", exp_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "exp2f", exp2_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "exp2", exp2_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "expm1f", expm1_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "expm1", expm1_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "lnf", ln_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "ln", ln_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "log2f", log2_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "log2", log2_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "log10f", log10_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "log10", log10_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "ln1pf", ln1p_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "ln1p", ln1p_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "powf", pow_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "pow", pow_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "cbrtf", cbrt_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "cbrt", cbrt_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "hypotf", hypotenuse_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "hypot", hypotenuse_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "sinf", sin_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "sin", sin_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "cosf", cos_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "cos", cos_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "tanf", tan_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "tan", tan_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "asinf", asin_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "asin", asin_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "acosf", acos_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "acos", acos_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "atanf", atan_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "atan", atan_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "sinhf", sinh_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "sinh", sinh_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "coshf", cosh_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "cosh", cosh_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "tanhf", tanh_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "tanh", tanh_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "asinhf", asinh_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "asinh", asinh_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "acoshf", acosh_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "acosh", acosh_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "atanhf", atanh_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "atanh", atanh_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "erff", erf_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "erf", erf_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "erfcf", erfc_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "erfc", erfc_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "gammaf", gamma_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "gamma", gamma_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "lgammaf", ln_gamma_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "lgamma", ln_gamma_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "lroundf", round_f32_i32)?;
-	manager.add_library_function(LIBRARY_NAME, "lround", round_f64_i32)?;
-	manager.add_library_function(LIBRARY_NAME, "llroundf", round_f32_i64)?;
-	manager.add_library_function(LIBRARY_NAME, "llround", round_f64_i64)?;
-	manager.add_library_function(LIBRARY_NAME, "frexpf", frexp_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "frexp", frexp_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "ldexpf", ldexp_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "ldexp", ldexp_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "modff", modf_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "modf", modf_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "ilogbf", logb_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "ilogb", logb_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "nextafterf", next_after_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "nextafter", next_after_f64)?;
-	manager.add_library_function(LIBRARY_NAME, "copysignf", copy_sign_f32)?;
-	manager.add_library_function(LIBRARY_NAME, "copysign", copy_sign_f64)?;
-
-	Some(())
-}
+use crate::ScriptManager;

+

+use super::LIBRARY_NAME;

+

+fn abs_i32(n: i32) -> i32 {

+	n.abs()

+}

+

+fn abs_i64(n: i64) -> i64 {

+	n.abs()

+}

+

+fn mod_f32(x: f32, y: f32) -> f32 {

+	libm::fmodf(x, y)

+}

+

+fn mod_f64(x: f64, y: f64) -> f64 {

+	libm::fmod(x, y)

+}

+

+fn remainder_f32(x: f32, y: f32) -> f32 {

+	libm::remainderf(x, y)

+}

+

+fn remainder_f64(x: f64, y: f64) -> f64 {

+	libm::remainder(x, y)

+}

+

+fn mul_add_f32(x: f32, y: f32, z: f32) -> f32 {

+	x.mul_add(y, z)

+}

+

+fn mul_add_f64(x: f64, y: f64, z: f64) -> f64 {

+	x.mul_add(y, z)

+}

+

+fn fdim_f32(x: f32, y: f32) -> f32 {

+	libm::fdimf(x, y)

+}

+

+fn fdim_f64(x: f64, y: f64) -> f64 {

+	libm::fdim(x, y)

+}

+

+fn exp_f32(x: f32) -> f32 {

+	x.exp()

+}

+

+fn exp_f64(x: f64) -> f64 {

+	x.exp()

+}

+

+fn exp2_f32(x: f32) -> f32 {

+	x.exp2()

+}

+

+fn exp2_f64(x: f64) -> f64 {

+	x.exp2()

+}

+

+fn expm1_f32(x: f32) -> f32 {

+	x.exp_m1()

+}

+

+fn expm1_f64(x: f64) -> f64 {

+	x.exp_m1()

+}

+

+fn ln_f32(x: f32) -> f32 {

+	x.ln()

+}

+

+fn ln_f64(x: f64) -> f64 {

+	x.ln()

+}

+

+fn log10_f32(x: f32) -> f32 {

+	x.log10()

+}

+

+fn log10_f64(x: f64) -> f64 {

+	x.log10()

+}

+

+fn log2_f32(x: f32) -> f32 {

+	x.log2()

+}

+

+fn log2_f64(x: f64) -> f64 {

+	x.log2()

+}

+

+fn ln1p_f32(x: f32) -> f32 {

+	x.ln_1p()

+}

+

+fn ln1p_f64(x: f64) -> f64 {

+	x.ln_1p()

+}

+

+fn pow_f32(base: f32, exponent: f32) -> f32 {

+	base.powf(exponent)

+}

+

+fn pow_f64(base: f64, exponent: f64) -> f64 {

+	base.powf(exponent)

+}

+

+fn cbrt_f32(x: f32) -> f32 {

+	x.cbrt()

+}

+

+fn cbrt_f64(x: f64) -> f64 {

+	x.cbrt()

+}

+

+fn hypotenuse_f32(x: f32, y: f32) -> f32 {

+	x.hypot(y)

+}

+

+fn hypotenuse_f64(x: f64, y: f64) -> f64 {

+	x.hypot(y)

+}

+

+fn sin_f32(x: f32) -> f32 {

+	x.sin()

+}

+

+fn sin_f64(x: f64) -> f64 {

+	x.sin()

+}

+

+fn cos_f32(x: f32) -> f32 {

+	x.cos()

+}

+

+fn cos_f64(x: f64) -> f64 {

+	x.cos()

+}

+

+fn tan_f32(x: f32) -> f32 {

+	x.tan()

+}

+

+fn tan_f64(x: f64) -> f64 {

+	x.tan()

+}

+

+fn asin_f32(x: f32) -> f32 {

+	x.asin()

+}

+

+fn asin_f64(x: f64) -> f64 {

+	x.asin()

+}

+

+fn acos_f32(x: f32) -> f32 {

+	x.acos()

+}

+

+fn acos_f64(x: f64) -> f64 {

+	x.acos()

+}

+

+fn atan_f32(x: f32) -> f32 {

+	x.atan()

+}

+

+fn atan_f64(x: f64) -> f64 {

+	x.atan()

+}

+

+fn sinh_f32(x: f32) -> f32 {

+	x.sinh()

+}

+

+fn sinh_f64(x: f64) -> f64 {

+	x.sinh()

+}

+

+fn cosh_f32(x: f32) -> f32 {

+	x.cosh()

+}

+

+fn cosh_f64(x: f64) -> f64 {

+	x.cosh()

+}

+

+fn tanh_f32(x: f32) -> f32 {

+	x.tanh()

+}

+

+fn tanh_f64(x: f64) -> f64 {

+	x.tanh()

+}

+

+fn asinh_f32(x: f32) -> f32 {

+	x.asinh()

+}

+

+fn asinh_f64(x: f64) -> f64 {

+	x.asinh()

+}

+

+fn acosh_f32(x: f32) -> f32 {

+	x.acosh()

+}

+

+fn acosh_f64(x: f64) -> f64 {

+	x.acosh()

+}

+

+fn atanh_f32(x: f32) -> f32 {

+	x.atanh()

+}

+

+fn atanh_f64(x: f64) -> f64 {

+	x.atanh()

+}

+

+fn erf_f32(x: f32) -> f32 {

+	libm::erff(x)

+}

+

+fn erf_f64(x: f64) -> f64 {

+	libm::erf(x)

+}

+

+fn erfc_f32(x: f32) -> f32 {

+	libm::erfcf(x)

+}

+

+fn erfc_f64(x: f64) -> f64 {

+	libm::erfc(x)

+}

+

+fn gamma_f32(x: f32) -> f32 {

+	libm::tgammaf(x)

+}

+

+fn gamma_f64(x: f64) -> f64 {

+	libm::tgamma(x)

+}

+

+fn ln_gamma_f32(x: f32) -> f32 {

+	libm::lgammaf(x)

+}

+

+fn ln_gamma_f64(x: f64) -> f64 {

+	libm::lgamma(x)

+}

+

+fn round_f32_i32(x: f32) -> i32 {

+	x.round() as i32

+}

+

+fn round_f64_i32(x: f64) -> i32 {

+	x.round() as i32

+}

+

+fn round_f32_i64(x: f32) -> i64 {

+	x.round() as i64

+}

+

+fn round_f64_i64(x: f64) -> i64 {

+	x.round() as i64

+}

+

+fn frexp_f32(x: f32) -> (f32, i32) {

+	libm::frexpf(x)

+}

+

+fn frexp_f64(x: f64) -> (f64, i32) {

+	libm::frexp(x)

+}

+

+fn ldexp_f32(x: f32, exp: i32) -> f32 {

+	libm::ldexpf(x, exp)

+}

+

+fn ldexp_f64(x: f64, exp: i32) -> f64 {

+	libm::ldexp(x, exp)

+}

+

+fn modf_f32(x: f32) -> (f32, f32) {

+	libm::modff(x)

+}

+

+fn modf_f64(x: f64) -> (f64, f64) {

+	libm::modf(x)

+}

+

+fn logb_f32(x: f32) -> i32 {

+	libm::ilogbf(x)

+}

+

+fn logb_f64(x: f64) -> i32 {

+	libm::ilogb(x)

+}

+

+fn next_after_f32(from: f32, to: f32) -> f32 {

+	libm::nextafterf(from, to)

+}

+

+fn next_after_f64(from: f64, to: f64) -> f64 {

+	libm::nextafter(from, to)

+}

+

+fn copy_sign_f32(x: f32, y: f32) -> f32 {

+	libm::copysignf(x, y)

+}

+

+fn copy_sign_f64(x: f64, y: f64) -> f64 {

+	libm::copysign(x, y)

+}

+

+pub fn library(manager: &mut ScriptManager) -> Option<()> {

+	manager.add_library_function(LIBRARY_NAME, "abs", abs_i32)?;

+	manager.add_library_function(LIBRARY_NAME, "labs", abs_i64)?;

+	manager.add_library_function(LIBRARY_NAME, "modf", mod_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "mod", mod_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "remf", remainder_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "rem", remainder_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "fmaf", mul_add_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "fma", mul_add_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "fdimf", fdim_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "fdim", fdim_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "expf", exp_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "exp", exp_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "exp2f", exp2_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "exp2", exp2_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "expm1f", expm1_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "expm1", expm1_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "lnf", ln_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "ln", ln_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "log2f", log2_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "log2", log2_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "log10f", log10_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "log10", log10_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "ln1pf", ln1p_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "ln1p", ln1p_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "powf", pow_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "pow", pow_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "cbrtf", cbrt_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "cbrt", cbrt_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "hypotf", hypotenuse_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "hypot", hypotenuse_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "sinf", sin_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "sin", sin_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "cosf", cos_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "cos", cos_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "tanf", tan_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "tan", tan_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "asinf", asin_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "asin", asin_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "acosf", acos_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "acos", acos_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "atanf", atan_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "atan", atan_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "sinhf", sinh_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "sinh", sinh_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "coshf", cosh_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "cosh", cosh_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "tanhf", tanh_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "tanh", tanh_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "asinhf", asinh_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "asinh", asinh_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "acoshf", acosh_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "acosh", acosh_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "atanhf", atanh_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "atanh", atanh_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "erff", erf_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "erf", erf_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "erfcf", erfc_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "erfc", erfc_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "gammaf", gamma_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "gamma", gamma_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "lgammaf", ln_gamma_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "lgamma", ln_gamma_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "lroundf", round_f32_i32)?;

+	manager.add_library_function(LIBRARY_NAME, "lround", round_f64_i32)?;

+	manager.add_library_function(LIBRARY_NAME, "llroundf", round_f32_i64)?;

+	manager.add_library_function(LIBRARY_NAME, "llround", round_f64_i64)?;

+	manager.add_library_function(LIBRARY_NAME, "frexpf", frexp_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "frexp", frexp_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "ldexpf", ldexp_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "ldexp", ldexp_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "modff", modf_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "modf", modf_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "ilogbf", logb_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "ilogb", logb_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "nextafterf", next_after_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "nextafter", next_after_f64)?;

+	manager.add_library_function(LIBRARY_NAME, "copysignf", copy_sign_f32)?;

+	manager.add_library_function(LIBRARY_NAME, "copysign", copy_sign_f64)?;

+

+	Some(())

+}

diff --git a/scripts/src/libs/mod.rs b/scripts/src/libs/mod.rs
index c6b1ffc..b77a0e2 100644
--- a/scripts/src/libs/mod.rs
+++ b/scripts/src/libs/mod.rs
@@ -1,19 +1,19 @@
-use crate::ScriptManager;
-
-mod allocate;
-mod buffer;
-mod ctype;
-mod math;
-mod system;
-
-const LIBRARY_NAME: &str = "alligator";
-
-pub fn add_alligator_library(manager: &mut ScriptManager) -> Option<()> {
-	allocate::library(manager)?;
-	buffer::library(manager)?;
-	ctype::library(manager)?;
-	math::library(manager)?;
-	system::library(manager)?;
-
-	Some(())
-}
+use crate::ScriptManager;

+

+mod allocate;

+mod buffer;

+mod ctype;

+mod math;

+mod system;

+

+const LIBRARY_NAME: &str = "alligator";

+

+pub fn add_alligator_library(manager: &mut ScriptManager) -> Option<()> {

+	allocate::library(manager)?;

+	buffer::library(manager)?;

+	ctype::library(manager)?;

+	math::library(manager)?;

+	system::library(manager)?;

+

+	Some(())

+}

diff --git a/scripts/src/libs/system.rs b/scripts/src/libs/system.rs
index 9c5a50c..4c7455b 100644
--- a/scripts/src/libs/system.rs
+++ b/scripts/src/libs/system.rs
@@ -1,154 +1,154 @@
-use std::borrow::Cow;
-use std::mem::align_of;
-
-use chrono::Offset;
-use wasmtime::{Caller, Memory};
-
-use crate::{ScriptManager, WasmScriptState};
-
-use super::LIBRARY_NAME;
-
-pub fn _get_memory<'a>(caller: &'a mut Caller<WasmScriptState>) -> (Memory, &'a mut [u8]) {
-	let memory = caller.get_export("memory").unwrap().into_memory().unwrap();
-	let mem_ptr = memory.data_mut(caller);
-	(memory, mem_ptr)
-}
-
-fn _get_string<'a>(
-	caller: &'a mut Caller<WasmScriptState>,
-	offset: u32,
-	length: u32,
-) -> Option<Cow<'a, str>> {
-	let (_, mem_ptr) = _get_memory(caller);
-	if (offset as usize + length as usize) > mem_ptr.len() {
-		return None;
-	}
-
-	Some(String::from_utf8_lossy(
-		&mem_ptr[offset as usize..length as usize],
-	))
-}
-
-fn _log(caller: &mut Caller<WasmScriptState>, level: log::Level, message: u32, length: u32) -> u32 {
-	let Some(message) = _get_string(caller, message, length) else {
-		return 4;
-	};
-	log::log!(level, "{}", message);
-	0
-}
-
-pub fn _alloc<'a>(
-	mut caller: &'a mut Caller<WasmScriptState>,
-	size: u32,
-	align: u32,
-) -> Option<(u32, &'a mut [u8])> {
-	// find bumper location in memory
-	let bump_offset = caller.data().bump_pointer;
-	let (memory, memory_ptr) = _get_memory(caller);
-	let bump_ptr = &memory_ptr[bump_offset as usize..];
-
-	// calculate pointer to the new allocation
-	let offset = bump_ptr.as_ptr().align_offset(align as usize);
-	let new_offset = bump_offset + offset as u32;
-
-	// update bump pointer
-	let bump_offset = &mut caller.data_mut().bump_pointer;
-	*bump_offset = new_offset + size;
-
-	// grow memory if necessary
-	let bump_offset = *bump_offset;
-	if memory.data_size(&caller) < bump_offset as usize {
-		let delta = (size + offset as u32) / (64 * 1024) + 1;
-		if memory.grow(&mut caller, delta as u64).is_err() {
-			return None;
-		}
-	}
-
-	let new_ptr = &mut _get_memory(caller).1[new_offset as usize..size as usize];
-	Some((new_offset, new_ptr))
-}
-
-fn allocate(mut caller: Caller<WasmScriptState>, size: u32, align: u32) -> u32 {
-	match _alloc(&mut caller, size, align) {
-		Some((ptr, _)) => ptr,
-		None => 0,
-	}
-}
-
-fn free_sized(mut caller: Caller<'_, WasmScriptState>, ptr: u32, size: u32) -> u32 {
-	let bump_offset = &mut caller.data_mut().bump_pointer;
-	if ptr + size == *bump_offset {
-		*bump_offset = ptr;
-	}
-
-	0
-}
-
-fn free_aligned_sized(
-	caller: Caller<'_, WasmScriptState>,
-	ptr: u32,
-	_alignment: u32,
-	size: u32,
-) -> u32 {
-	free_sized(caller, ptr, size)
-}
-
-fn env_var(mut caller: Caller<'_, WasmScriptState>, name: u32, length: u32) -> u32 {
-	let Some(name) = _get_string(&mut caller, name, length) else {
-		return 4;
-	};
-	let Ok(value) = std::env::var(name.to_string()) else {
-		return 1;
-	};
-
-	let Some((offset, ptr)) = _alloc(&mut caller, value.len() as u32, align_of::<u8>() as u32)
-	else {
-		return 0;
-	};
-	ptr.clone_from_slice(value.as_bytes());
-
-	offset
-}
-
-fn random_number() -> u64 {
-	rand::random()
-}
-
-fn current_time_utc() -> (i64, u32) {
-	let duration = chrono::Utc::now() - chrono::DateTime::<chrono::Utc>::MIN_UTC;
-	(
-		duration.num_seconds(),
-		duration.to_std().unwrap().subsec_nanos(),
-	)
-}
-
-fn local_offset() -> i32 {
-	chrono::Local::now().offset().fix().local_minus_utc()
-}
-
-fn log(mut caller: Caller<'_, WasmScriptState>, message: u32, length: u32) {
-	_log(&mut caller, log::Level::Info, message, length);
-}
-
-fn log_warn(mut caller: Caller<'_, WasmScriptState>, message: u32, length: u32) {
-	_log(&mut caller, log::Level::Warn, message, length);
-}
-
-fn log_error(mut caller: Caller<'_, WasmScriptState>, message: u32, length: u32) {
-	_log(&mut caller, log::Level::Error, message, length);
-}
-
-pub fn library(manager: &mut ScriptManager) -> Option<()> {
-	manager.add_library_function(LIBRARY_NAME, "aligned_alloc", allocate)?;
-	manager.add_library_function(LIBRARY_NAME, "free_sized", free_sized)?;
-	manager.add_library_function(LIBRARY_NAME, "free_aligned_sized", free_aligned_sized)?;
-	manager.add_library_function(LIBRARY_NAME, "env_var", env_var)?;
-	manager.add_library_function(LIBRARY_NAME, "random_number", random_number)?;
-	manager.add_library_function(LIBRARY_NAME, "current_time_utc", current_time_utc)?;
-	manager.add_library_function(LIBRARY_NAME, "local_offset", local_offset)?;
-	manager.add_library_function(LIBRARY_NAME, "log", log)?;
-	manager.add_library_function(LIBRARY_NAME, "log_warn", log_warn)?;
-	manager.add_library_function(LIBRARY_NAME, "log_error", log_error)?;
-
-	Some(())
-}
+use std::borrow::Cow;

+use std::mem::align_of;

+

+use chrono::Offset;

+use wasmtime::{Caller, Memory};

+

+use crate::{ScriptManager, WasmScriptState};

+

+use super::LIBRARY_NAME;

+

+pub fn _get_memory<'a>(caller: &'a mut Caller<WasmScriptState>) -> (Memory, &'a mut [u8]) {

+	let memory = caller.get_export("memory").unwrap().into_memory().unwrap();

+	let mem_ptr = memory.data_mut(caller);

+	(memory, mem_ptr)

+}

+

+fn _get_string<'a>(

+	caller: &'a mut Caller<WasmScriptState>,

+	offset: u32,

+	length: u32,

+) -> Option<Cow<'a, str>> {

+	let (_, mem_ptr) = _get_memory(caller);

+	if (offset as usize + length as usize) > mem_ptr.len() {

+		return None;

+	}

+

+	Some(String::from_utf8_lossy(

+		&mem_ptr[offset as usize..length as usize],

+	))

+}

+

+fn _log(caller: &mut Caller<WasmScriptState>, level: log::Level, message: u32, length: u32) -> u32 {

+	let Some(message) = _get_string(caller, message, length) else {

+		return 4;

+	};

+	log::log!(level, "{}", message);

+	0

+}

+

+pub fn _alloc<'a>(

+	mut caller: &'a mut Caller<WasmScriptState>,

+	size: u32,

+	align: u32,

+) -> Option<(u32, &'a mut [u8])> {

+	// find bumper location in memory

+	let bump_offset = caller.data().bump_pointer;

+	let (memory, memory_ptr) = _get_memory(caller);

+	let bump_ptr = &memory_ptr[bump_offset as usize..];

+

+	// calculate pointer to the new allocation

+	let offset = bump_ptr.as_ptr().align_offset(align as usize);

+	let new_offset = bump_offset + offset as u32;

+

+	// update bump pointer

+	let bump_offset = &mut caller.data_mut().bump_pointer;

+	*bump_offset = new_offset + size;

+

+	// grow memory if necessary

+	let bump_offset = *bump_offset;

+	if memory.data_size(&caller) < bump_offset as usize {

+		let delta = (size + offset as u32) / (64 * 1024) + 1;

+		if memory.grow(&mut caller, delta as u64).is_err() {

+			return None;

+		}

+	}

+

+	let new_ptr = &mut _get_memory(caller).1[new_offset as usize..size as usize];

+	Some((new_offset, new_ptr))

+}

+

+fn allocate(mut caller: Caller<WasmScriptState>, size: u32, align: u32) -> u32 {

+	match _alloc(&mut caller, size, align) {

+		Some((ptr, _)) => ptr,

+		None => 0,

+	}

+}

+

+fn free_sized(mut caller: Caller<'_, WasmScriptState>, ptr: u32, size: u32) -> u32 {

+	let bump_offset = &mut caller.data_mut().bump_pointer;

+	if ptr + size == *bump_offset {

+		*bump_offset = ptr;

+	}

+

+	0

+}

+

+fn free_aligned_sized(

+	caller: Caller<'_, WasmScriptState>,

+	ptr: u32,

+	_alignment: u32,

+	size: u32,

+) -> u32 {

+	free_sized(caller, ptr, size)

+}

+

+fn env_var(mut caller: Caller<'_, WasmScriptState>, name: u32, length: u32) -> u32 {

+	let Some(name) = _get_string(&mut caller, name, length) else {

+		return 4;

+	};

+	let Ok(value) = std::env::var(name.to_string()) else {

+		return 1;

+	};

+

+	let Some((offset, ptr)) = _alloc(&mut caller, value.len() as u32, align_of::<u8>() as u32)

+	else {

+		return 0;

+	};

+	ptr.clone_from_slice(value.as_bytes());

+

+	offset

+}

+

+fn random_number() -> u64 {

+	rand::random()

+}

+

+fn current_time_utc() -> (i64, u32) {

+	let duration = chrono::Utc::now() - chrono::DateTime::<chrono::Utc>::MIN_UTC;

+	(

+		duration.num_seconds(),

+		duration.to_std().unwrap().subsec_nanos(),

+	)

+}

+

+fn local_offset() -> i32 {

+	chrono::Local::now().offset().fix().local_minus_utc()

+}

+

+fn log(mut caller: Caller<'_, WasmScriptState>, message: u32, length: u32) {

+	_log(&mut caller, log::Level::Info, message, length);

+}

+

+fn log_warn(mut caller: Caller<'_, WasmScriptState>, message: u32, length: u32) {

+	_log(&mut caller, log::Level::Warn, message, length);

+}

+

+fn log_error(mut caller: Caller<'_, WasmScriptState>, message: u32, length: u32) {

+	_log(&mut caller, log::Level::Error, message, length);

+}

+

+pub fn library(manager: &mut ScriptManager) -> Option<()> {

+	manager.add_library_function(LIBRARY_NAME, "aligned_alloc", allocate)?;

+	manager.add_library_function(LIBRARY_NAME, "free_sized", free_sized)?;

+	manager.add_library_function(LIBRARY_NAME, "free_aligned_sized", free_aligned_sized)?;

+	manager.add_library_function(LIBRARY_NAME, "env_var", env_var)?;

+	manager.add_library_function(LIBRARY_NAME, "random_number", random_number)?;

+	manager.add_library_function(LIBRARY_NAME, "current_time_utc", current_time_utc)?;

+	manager.add_library_function(LIBRARY_NAME, "local_offset", local_offset)?;

+	manager.add_library_function(LIBRARY_NAME, "log", log)?;

+	manager.add_library_function(LIBRARY_NAME, "log_warn", log_warn)?;

+	manager.add_library_function(LIBRARY_NAME, "log_error", log_error)?;

+

+	Some(())

+}