Bump gc-arena and ctor; mark ctor hooks unsafe

ssrlive · ssrlive · commit a2ae871c45e5 · 2026-06-10T23:24:15.000+08:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -24,9 +24,7 @@ std = []
 bitflags = { version = "2.11.1", default-features = false, features = [] }
 chrono = { version = "0.4.44", features = ["serde"] }
 crossbeam-channel = "0.5.15"
-gc-arena = { git = "https://github.com/kyren/gc-arena.git", rev = "75671ae", features = [
-    "indexmap",
-] }
+gc-arena = { version = "0.6.0", features = ["indexmap"] }
 indexmap = "2.14.0"
 log = "0.4.29"
 num-bigint = "0.4.6"
@@ -51,7 +49,7 @@ windows-sys = { version = "0.61.2", optional = true, features = [
 
 [dev-dependencies]
 criterion = { version = "0.8.2", features = ["html_reports"] }
-ctor = "0.10.0"
+ctor = "1.0.7"
 env_logger = { version = "0.11.10" }
 
 [[bench]]
diff --git a/benches/bigint_bench.rs b/benches/bigint_bench.rs
@@ -7,7 +7,7 @@ use std::hint::black_box;
 // Compares: parsing per-op (current engine approach) vs parsed/cached reuse.
 
 // Initialize logger for benchmark so `RUST_LOG` is honored.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_bench_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).try_init();
 }
diff --git a/benches/promise_benchmarks.rs b/benches/promise_benchmarks.rs
@@ -5,7 +5,7 @@ use std::hint::black_box;
 // cargo bench --profile dev
 
 // Initialize logger for benchmark so `RUST_LOG` is honored.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_bench_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).try_init();
 }
diff --git a/tests/accessor_tests.rs b/tests/accessor_tests.rs
@@ -3,7 +3,7 @@ use javascript::evaluate_script;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/array_literals.rs b/tests/array_literals.rs
@@ -2,7 +2,7 @@ use javascript::evaluate_script;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/async_await_regressions.rs b/tests/async_await_regressions.rs
@@ -1,7 +1,7 @@
 use javascript::*;
 
 // Initialize logger for these integration tests so `RUST_LOG` is honored.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/async_await_tests.rs b/tests/async_await_tests.rs
@@ -2,7 +2,7 @@ use javascript::*;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/async_manual.rs b/tests/async_manual.rs
@@ -1,7 +1,7 @@
 use javascript::*;
 
 // Initialize logger for tests
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/async_regression_tests.rs b/tests/async_regression_tests.rs
@@ -1,7 +1,7 @@
 use javascript::*;
 use serde_json::Value;
 
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/basic_arithmetic.rs b/tests/basic_arithmetic.rs
@@ -2,7 +2,7 @@ use javascript::*;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/bigint_api.rs b/tests/bigint_api.rs
@@ -1,6 +1,6 @@
 use javascript::evaluate_script;
 
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/bigint_asintn.rs b/tests/bigint_asintn.rs
@@ -1,6 +1,6 @@
 use javascript::evaluate_script;
 
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/bigint_tests.rs b/tests/bigint_tests.rs
@@ -2,7 +2,7 @@ use javascript::evaluate_script;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/builtin_functions.rs b/tests/builtin_functions.rs
@@ -1,6 +1,6 @@
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/class_tests.rs b/tests/class_tests.rs
@@ -2,7 +2,7 @@ use javascript::evaluate_script;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/comment_tests.rs b/tests/comment_tests.rs
@@ -2,7 +2,7 @@ use javascript::evaluate_script;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/compound_assign.rs b/tests/compound_assign.rs
@@ -2,7 +2,7 @@ use javascript::*;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/compound_assign_edgecases.rs b/tests/compound_assign_edgecases.rs
@@ -2,7 +2,7 @@ use javascript::*;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/conditional_expressions.rs b/tests/conditional_expressions.rs
@@ -1,6 +1,6 @@
 use javascript::*;
 
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/const_tests.rs b/tests/const_tests.rs
@@ -2,7 +2,7 @@ use javascript::evaluate_script;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/control_flow.rs b/tests/control_flow.rs
@@ -2,7 +2,7 @@ use javascript::evaluate_script;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/date_tests.rs b/tests/date_tests.rs
@@ -1,6 +1,6 @@
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/destructuring_defaults.rs b/tests/destructuring_defaults.rs
@@ -1,7 +1,7 @@
 use javascript::*;
 
 // Initialize logger for integration tests.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/destructuring_tests.rs b/tests/destructuring_tests.rs
@@ -2,7 +2,7 @@ use javascript::*;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/equality_concat.rs b/tests/equality_concat.rs
@@ -1,6 +1,6 @@
 use javascript::*;
 
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/error_to_string_tests.rs b/tests/error_to_string_tests.rs
@@ -2,7 +2,7 @@ use javascript::*;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/function_call_env_edgecases.rs b/tests/function_call_env_edgecases.rs
@@ -1,6 +1,6 @@
 use javascript::*;
 
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/functions.rs b/tests/functions.rs
@@ -2,7 +2,7 @@ use javascript::*;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/import_meta_tests.rs b/tests/import_meta_tests.rs
@@ -1,6 +1,6 @@
 use javascript::*;
 
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/increment_decrement.rs b/tests/increment_decrement.rs
@@ -2,7 +2,7 @@ use javascript::*;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/index_nullish_key_order.rs b/tests/index_nullish_key_order.rs
@@ -1,7 +1,7 @@
 use javascript::*;
 
 // Ensure logger initialization for tests
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/intl_get_invalid_language_tags.rs b/tests/intl_get_invalid_language_tags.rs
@@ -2,7 +2,7 @@ use javascript::evaluate_script;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/json_module_tests.rs b/tests/json_module_tests.rs
@@ -1,6 +1,6 @@
 use javascript::*;
 
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/logical_assignments.rs b/tests/logical_assignments.rs
@@ -3,7 +3,7 @@ use javascript::tokenize;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/map_set_tests.rs b/tests/map_set_tests.rs
@@ -2,7 +2,7 @@ use javascript::evaluate_script;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/nested_single_statement_bodies.rs b/tests/nested_single_statement_bodies.rs
@@ -1,7 +1,7 @@
 use javascript::evaluate_script;
 
 // Init logger for tests
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/nullish_coalescing_tests.rs b/tests/nullish_coalescing_tests.rs
@@ -2,7 +2,7 @@ use javascript::*;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/number_tests.rs b/tests/number_tests.rs
@@ -2,7 +2,7 @@ use javascript::*;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/object_literals.rs b/tests/object_literals.rs
@@ -2,7 +2,7 @@ use javascript::*;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/optional_chaining.rs b/tests/optional_chaining.rs
@@ -2,7 +2,7 @@ use javascript::evaluate_script;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/os_tests.rs b/tests/os_tests.rs
@@ -2,7 +2,7 @@ use javascript::*;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/parse_error_metadata.rs b/tests/parse_error_metadata.rs
@@ -1,7 +1,7 @@
 use javascript::*;
 
 // Initialize logger for these tests
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/parser_and_tokenization.rs b/tests/parser_and_tokenization.rs
@@ -1,6 +1,6 @@
 use javascript::*;
 
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/parser_named_function_expr.rs b/tests/parser_named_function_expr.rs
@@ -1,7 +1,7 @@
 use javascript::*;
 
 // Initialize logger for these tests
-#[ctor::ctor]
+#[ctor::ctor(unsafe)]
 fn __init_test_logger() {
     let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();
 }
diff --git a/tests/parser_named_function_expr_more.rs b/tests/parser_named_function_expr_more.rs
diff --git a/tests/promise_deep_chain.rs b/tests/promise_deep_chain.rs
diff --git a/tests/promise_tests.rs b/tests/promise_tests.rs
diff --git a/tests/proxy_tests.rs b/tests/proxy_tests.rs
diff --git a/tests/reflect_apply_construct_tests.rs b/tests/reflect_apply_construct_tests.rs
diff --git a/tests/reflect_tests.rs b/tests/reflect_tests.rs
diff --git a/tests/regexp_tests.rs b/tests/regexp_tests.rs
diff --git a/tests/single_statement_bodies.rs b/tests/single_statement_bodies.rs
diff --git a/tests/species_regression_tests.rs b/tests/species_regression_tests.rs
diff --git a/tests/stack_traces.rs b/tests/stack_traces.rs
diff --git a/tests/std_tests.rs b/tests/std_tests.rs
diff --git a/tests/string_literals.rs b/tests/string_literals.rs
diff --git a/tests/super_newtarget_propagation.rs b/tests/super_newtarget_propagation.rs
diff --git a/tests/symbol_additional_tests.rs b/tests/symbol_additional_tests.rs
diff --git a/tests/symbol_property_tests.rs b/tests/symbol_property_tests.rs
diff --git a/tests/symbol_static_tests.rs b/tests/symbol_static_tests.rs
diff --git a/tests/timeout_tests.rs b/tests/timeout_tests.rs
diff --git a/tests/tmpfile_tests.rs b/tests/tmpfile_tests.rs
diff --git a/tests/trailing_comma_array.rs b/tests/trailing_comma_array.rs
diff --git a/tests/try_catch.rs b/tests/try_catch.rs
diff --git a/tests/typedarray_tests.rs b/tests/typedarray_tests.rs
diff --git a/tests/weakmap_weakset_tests.rs b/tests/weakmap_weakset_tests.rs

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ use std::hint::black_box;`
`7`	`7`	`// Compares: parsing per-op (current engine approach) vs parsed/cached reuse.`
`8`	`8`
`9`	`9`	// Initialize logger for benchmark so `RUST_LOG` is honored.
`10`		`-#[ctor::ctor]`
	`10`	`+#[ctor::ctor(unsafe)]`
`11`	`11`	`fn __init_bench_logger() {`
`12`	`12`	`let _ = env_logger::Builder::from_env(env_logger::Env::default()).try_init();`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ use std::hint::black_box;`
`5`	`5`	`// cargo bench --profile dev`
`6`	`6`
`7`	`7`	// Initialize logger for benchmark so `RUST_LOG` is honored.
`8`		`-#[ctor::ctor]`
	`8`	`+#[ctor::ctor(unsafe)]`
`9`	`9`	`fn __init_bench_logger() {`
`10`	`10`	`let _ = env_logger::Builder::from_env(env_logger::Env::default()).try_init();`
`11`	`11`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@ use javascript::evaluate_script;`
`3`	`3`
`4`	`4`	// Initialize logger for this integration test binary so `RUST_LOG` is honored.
`5`	`5`	// Using `ctor` ensures initialization runs before tests start.
`6`		`-#[ctor::ctor]`
	`6`	`+#[ctor::ctor(unsafe)]`
`7`	`7`	`fn __init_test_logger() {`
`8`	`8`	`let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();`
`9`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@ use javascript::evaluate_script;`
`2`	`2`
`3`	`3`	// Initialize logger for this integration test binary so `RUST_LOG` is honored.
`4`	`4`	// Using `ctor` ensures initialization runs before tests start.
`5`		`-#[ctor::ctor]`
	`5`	`+#[ctor::ctor(unsafe)]`
`6`	`6`	`fn __init_test_logger() {`
`7`	`7`	`let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();`
`8`	`8`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`use javascript::*;`
`2`	`2`
`3`	`3`	// Initialize logger for these integration tests so `RUST_LOG` is honored.
`4`		`-#[ctor::ctor]`
	`4`	`+#[ctor::ctor(unsafe)]`
`5`	`5`	`fn __init_test_logger() {`
`6`	`6`	`let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();`
`7`	`7`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@ use javascript::*;`
`2`	`2`
`3`	`3`	// Initialize logger for this integration test binary so `RUST_LOG` is honored.
`4`	`4`	// Using `ctor` ensures initialization runs before tests start.
`5`		`-#[ctor::ctor]`
	`5`	`+#[ctor::ctor(unsafe)]`
`6`	`6`	`fn __init_test_logger() {`
`7`	`7`	`let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();`
`8`	`8`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`use javascript::*;`
`2`	`2`
`3`	`3`	`// Initialize logger for tests`
`4`		`-#[ctor::ctor]`
	`4`	`+#[ctor::ctor(unsafe)]`
`5`	`5`	`fn __init_test_logger() {`
`6`	`6`	`let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();`
`7`	`7`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`use javascript::*;`
`2`	`2`	`use serde_json::Value;`
`3`	`3`
`4`		`-#[ctor::ctor]`
	`4`	`+#[ctor::ctor(unsafe)]`
`5`	`5`	`fn __init_test_logger() {`
`6`	`6`	`let _ = env_logger::Builder::from_env(env_logger::Env::default()).is_test(true).try_init();`
`7`	`7`	`}`