pkhex 25.12.21 → 26.1.22

package/driver.c

@@ -42,6 +42,7 @@ void bindings_initialize_internals ();
 char *monoeg_g_getenv(const char *variable);
 int monoeg_g_setenv(const char *variable, const char *value, int overwrite);
 char *mono_method_get_full_name (MonoMethod *method);
+char *mono_method_full_name (MonoMethod *method, int32_t signature);
 
 #ifndef INVARIANT_TIMEZONE
 extern void mono_register_timezones_bundle (void);
@@ -62,8 +63,6 @@ int mono_regression_test_step (int verbose_level, char *image, char *method_name
 
 static MonoDomain *root_domain;
 
-#define RUNTIMECONFIG_BIN_FILE "runtimeconfig.bin"
-
 extern void mono_wasm_trace_logger (const char *log_domain, const char *log_level, const char *message, mono_bool fatal, void *user_data);
 
 static void
@@ -180,17 +179,36 @@ cleanup_runtime_config (MonovmRuntimeConfigArguments *args, void *user_data)
 	free (user_data);
 }
 
+static int runtime_initialized = 0;
+
 EMSCRIPTEN_KEEPALIVE void
-mono_wasm_load_runtime (int debug_level)
+mono_wasm_load_runtime (int debug_level, int propertyCount, const char **propertyKeys, const char **propertyValues)
 {
+	runtime_initialized = 1;
 	const char *interp_opts = "";
 
 #ifndef INVARIANT_GLOBALIZATION
 	mono_wasm_link_icu_shim ();
 #endif
 
-	// When the list of app context properties changes, please update RuntimeConfigReservedProperties for
-	// target _WasmGenerateRuntimeConfig in BrowserWasmApp.targets file
+	monovm_initialize (propertyCount, propertyKeys, propertyValues);
+
+#ifndef INVARIANT_TIMEZONE
+	char* invariant_timezone = monoeg_g_getenv ("DOTNET_SYSTEM_TIMEZONE_INVARIANT");
+	if (strcmp(invariant_timezone, "true") != 0 && strcmp(invariant_timezone, "1") != 0)
+		mono_register_timezones_bundle ();
+#endif /* INVARIANT_TIMEZONE */
+
+	root_domain = mono_wasm_load_runtime_common (debug_level, wasm_trace_logger, interp_opts);
+
+	bindings_initialize_internals();
+}
+
+int initialize_runtime()
+{
+    if (runtime_initialized == 1)
+		return 0;
+
 	const char *appctx_keys[2];
 	appctx_keys [0] = "APP_CONTEXT_BASE_DIRECTORY";
 	appctx_keys [1] = "RUNTIME_IDENTIFIER";
@@ -199,32 +217,10 @@ mono_wasm_load_runtime (int debug_level)
 	appctx_values [0] = "/";
 	appctx_values [1] = "browser-wasm";
 
-	char *file_name = RUNTIMECONFIG_BIN_FILE;
-	int str_len = strlen (file_name) + 1; // +1 is for the "/"
-	char *file_path = (char *)malloc (sizeof (char) * (str_len +1)); // +1 is for the terminating null character
-	int num_char = snprintf (file_path, (str_len + 1), "/%s", file_name);
-	struct stat buffer;
-
-	assert (num_char > 0 && num_char == str_len);
-
-	if (stat (file_path, &buffer) == 0) {
-		MonovmRuntimeConfigArguments *arg = (MonovmRuntimeConfigArguments *)malloc (sizeof (MonovmRuntimeConfigArguments));
-		arg->kind = 0;
-		arg->runtimeconfig.name.path = file_path;
-		monovm_runtimeconfig_initialize (arg, cleanup_runtime_config, file_path);
-	} else {
-		free (file_path);
-	}
-
-	monovm_initialize (2, appctx_keys, appctx_values);
-
-#ifndef INVARIANT_TIMEZONE
-	mono_register_timezones_bundle ();
-#endif /* INVARIANT_TIMEZONE */
-
-	root_domain = mono_wasm_load_runtime_common (debug_level, wasm_trace_logger, interp_opts);
+	// this does not support loading runtimeConfig.json part of boot.config.json
+	mono_wasm_load_runtime (0, 2, appctx_keys, appctx_values);
 
-	bindings_initialize_internals();
+	return 0;
 }
 
 EMSCRIPTEN_KEEPALIVE void
@@ -418,14 +414,14 @@ mono_wasm_profiler_init_aot (const char *desc)
 
 #endif
 
-#ifdef ENABLE_BROWSER_PROFILER
+#ifdef ENABLE_DEVTOOLS_PROFILER
 
-void mono_profiler_init_browser (const char *desc);
+void mono_profiler_init_browser_devtools (const char *desc);
 
 EMSCRIPTEN_KEEPALIVE void
-mono_wasm_profiler_init_browser (const char *desc)
+mono_wasm_profiler_init_browser_devtools (const char *desc)
 {
-	mono_profiler_init_browser (desc);
+	mono_profiler_init_browser_devtools (desc);
 }
 
 #endif
@@ -504,8 +500,8 @@ EMSCRIPTEN_KEEPALIVE int mono_wasm_f64_to_i52 (int64_t *destination, double valu
 }
 
 // JS is responsible for freeing this
-EMSCRIPTEN_KEEPALIVE const char * mono_wasm_method_get_full_name (MonoMethod *method) {
-	const char *res;
+EMSCRIPTEN_KEEPALIVE char * mono_wasm_method_get_full_name (MonoMethod *method) {
+	char *res;
 	MONO_ENTER_GC_UNSAFE;
 	res = mono_method_get_full_name (method);
 	MONO_EXIT_GC_UNSAFE;
@@ -520,6 +516,24 @@ EMSCRIPTEN_KEEPALIVE const char * mono_wasm_method_get_name (MonoMethod *method)
 	return res;
 }
 
+EMSCRIPTEN_KEEPALIVE char * mono_wasm_method_get_name_ex (MonoMethod *method) {
+	char *res;
+	MONO_ENTER_GC_UNSAFE;
+	const char *method_name = mono_method_get_name (method);
+	// starts with .ctor or .cctor
+	if (!method_name) {
+		res = strdup ("<unknown>");
+	} else if (method_name && mono_method_get_flags (method, NULL) & 0x0800 /* METHOD_ATTRIBUTE_SPECIAL_NAME */ && strlen (method_name) < 7) {
+		res = (char *) malloc (128);
+		snprintf (res, 128,"%s.%s", mono_class_get_name (mono_method_get_class (method)), method_name);
+		res[127] = '\0';
+	} else {
+		res = strdup (method_name);
+	}
+	MONO_EXIT_GC_UNSAFE;
+	return res;
+}
+
 EMSCRIPTEN_KEEPALIVE float mono_wasm_get_f32_unaligned (const float *src) {
 	return *src;
 }

package/emcc-link.rsp

@@ -7,7 +7,7 @@
 -s FORCE_FILESYSTEM=1
 -s DEFAULT_LIBRARY_FUNCS_TO_INCLUDE="[]"
 -s EXPORTED_RUNTIME_METHODS="['FS','out','err','ccall','cwrap','setValue','getValue','UTF8ToString','UTF8ArrayToString','lengthBytesUTF8','stringToUTF8Array','FS_createPath','FS_createDataFile','removeRunDependency','addRunDependency','addFunction','safeSetTimeout','runtimeKeepalivePush','runtimeKeepalivePop','maybeExit','abort','wasmExports']"
--s EXPORTED_FUNCTIONS=_free,_htons,_malloc,_sbrk,_memalign,_memset,_ntohs,stackAlloc,stackRestore,stackSave,_emscripten_force_exit,_fmod,_atan2,_fma,_pow,_fmodf,_atan2f,_fmaf,_powf,_asin,_asinh,_acos,_acosh,_atan,_atanh,_cbrt,_cos,_cosh,_exp,_log,_log2,_log10,_sin,_sinh,_tan,_tanh,_asinf,_asinhf,_acosf,_acoshf,_atanf,_atanhf,_cbrtf,_cosf,_coshf,_expf,_logf,_log2f,_log10f,_sinf,_sinhf,_tanf,_tanhf
+-s EXPORTED_FUNCTIONS=_free,_htons,_malloc,_sbrk,_memalign,_posix_memalign,_memset,_ntohs,stackAlloc,stackRestore,stackSave,_emscripten_force_exit,_fmod,_atan2,_fma,_pow,_fmodf,_atan2f,_fmaf,_powf,_asin,_asinh,_acos,_acosh,_atan,_atanh,_cbrt,_cos,_cosh,_exp,_log,_log2,_log10,_sin,_sinh,_tan,_tanh,_asinf,_asinhf,_acosf,_acoshf,_atanf,_atanhf,_cbrtf,_cosf,_coshf,_expf,_logf,_log2f,_log10f,_sinf,_sinhf,_tanf,_tanhf
 --source-map-base http://example.com
 -s WASM_BIGINT=1
 -s EXPORT_NAME="'createDotnetRuntime'"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pkhex",
-  "version": "25.12.21",
+  "version": "26.1.22",
   "description": "WebAssembly library wrapping PKHeX.Core for Pokemon save file editing in JavaScript/TypeScript",
   "type": "module",
   "main": "dist/index.js",

package/pinvoke.c

@@ -23,39 +23,71 @@ mono_wasm_pinvoke_vararg_stub (void)
 	/* This is just a stub used to mark vararg pinvokes */
 }
 
+int
+table_compare_name (const void *t1, const void *t2)
+{
+	return strcmp (((PinvokeTable*)t1)->name, ((PinvokeTable*)t2)->name);
+}
+
 void*
 wasm_dl_lookup_pinvoke_table (const char *name)
 {
-	for (int i = 0; i < sizeof (pinvoke_tables) / sizeof (void*); ++i) {
-		if (!strcmp (name, pinvoke_names [i]))
-			return pinvoke_tables [i];
-	}
-	return NULL;
+	PinvokeImport needle = { name, NULL };
+	return bsearch (&needle, pinvoke_tables, (sizeof (pinvoke_tables) / sizeof (PinvokeTable)), sizeof (PinvokeTable), table_compare_name);
 }
 
 int
 wasm_dl_is_pinvoke_table (void *handle)
 {
-	for (int i = 0; i < sizeof (pinvoke_tables) / sizeof (void*); ++i) {
-		if (pinvoke_tables [i] == handle) {
+	for (int i = 0; i < sizeof (pinvoke_tables) / sizeof (PinvokeTable); ++i) {
+		if (&pinvoke_tables[i] == handle) {
 			return 1;
 		}
 	}
 	return 0;
 }
 
+static int
+export_compare_key (const void *k1, const void *k2)
+{
+	return strcmp (((UnmanagedExport*)k1)->key, ((UnmanagedExport*)k2)->key);
+}
+
+static int
+export_compare_key_and_token (const void *k1, const void *k2)
+{
+	UnmanagedExport *e1 = (UnmanagedExport*)k1;
+	UnmanagedExport *e2 = (UnmanagedExport*)k2;
+
+	// first compare by key
+	int compare = strcmp (e1->key, e2->key);
+	if (compare)
+		return compare;
+
+	// then by token
+	return (int)(e1->token - e2->token);
+}
+
 void*
-wasm_dl_get_native_to_interp (const char *key, void *extra_arg)
+wasm_dl_get_native_to_interp (uint32_t token, const char *key, void *extra_arg)
 {
 #ifdef GEN_PINVOKE
-	for (int i = 0; i < sizeof (wasm_native_to_interp_map) / sizeof (void*); ++i) {
-		if (!strcmp (wasm_native_to_interp_map [i], key)) {
-			void *addr = wasm_native_to_interp_funcs [i];
-			wasm_native_to_interp_ftndescs [i] = *(InterpFtnDesc*)extra_arg;
-			return addr;
-		}
+	UnmanagedExport needle = { key, token, NULL };
+	int count = (sizeof (wasm_native_to_interp_table) / sizeof (UnmanagedExport));
+
+	// comparison must match the one used in the PInvokeTableGenerator to ensure the same order
+	UnmanagedExport *result = bsearch (&needle, wasm_native_to_interp_table, count, sizeof (UnmanagedExport), export_compare_key_and_token);
+	if (!result) {
+		// assembly may have been trimmed / modified, try to find by key only
+		result = bsearch (&needle, wasm_native_to_interp_table, count, sizeof (UnmanagedExport), export_compare_key);
 	}
-	return NULL;
+
+	if (!result)
+		return NULL;
+
+	void *addr = result->func;
+	wasm_native_to_interp_ftndescs [result - wasm_native_to_interp_table] = *(InterpFtnDesc*)extra_arg;
+	return addr;
 #else
 	return NULL;
 #endif

package/pinvoke.h

@@ -8,6 +8,18 @@ typedef struct {
 	void *func;
 } PinvokeImport;
 
+typedef struct {
+	const char *name;
+	PinvokeImport *imports;
+	int count;
+} PinvokeTable;
+
+typedef struct {
+	const char *key;
+	uint32_t token;
+	void *func;
+} UnmanagedExport;
+
 typedef struct {
 	void *func;
 	void *arg;
@@ -20,7 +32,7 @@ int
 wasm_dl_is_pinvoke_table (void *handle);
 
 void*
-wasm_dl_get_native_to_interp (const char *key, void *extra_arg);
+wasm_dl_get_native_to_interp (uint32_t token, const char *key, void *extra_arg);
 
 void
 mono_wasm_pinvoke_vararg_stub (void);
@@ -45,6 +57,6 @@ double
 mono_wasm_interp_method_args_get_darg (MonoInterpMethodArguments *margs, int i);
 
 void*
-mono_wasm_interp_method_args_get_retval  (MonoInterpMethodArguments *margs);
+mono_wasm_interp_method_args_get_retval (MonoInterpMethodArguments *margs);
 
 #endif

package/runtime.c

@@ -62,8 +62,6 @@
 #define EMSCRIPTEN_KEEPALIVE
 #endif
 
-int mono_wasm_enable_gc = 1;
-
 /* Missing from public headers */
 char *mono_fixup_symbol_name (const char *prefix, const char *key, const char *suffix);
 void mono_icall_table_init (void);
@@ -199,29 +197,43 @@ init_icall_table (void)
 static void*
 get_native_to_interp (MonoMethod *method, void *extra_arg)
 {
-	void *addr;
-
+	void *addr = NULL;
 	MONO_ENTER_GC_UNSAFE;
 	MonoClass *klass = mono_method_get_class (method);
 	MonoImage *image = mono_class_get_image (klass);
 	MonoAssembly *assembly = mono_image_get_assembly (image);
 	MonoAssemblyName *aname = mono_assembly_get_name (assembly);
 	const char *name = mono_assembly_name_get_name (aname);
+	const char *namespace = mono_class_get_namespace (klass);
 	const char *class_name = mono_class_get_name (klass);
 	const char *method_name = mono_method_get_name (method);
-	char key [128];
+	MonoMethodSignature *sig = mono_method_signature (method);
+	uint32_t param_count = mono_signature_get_param_count (sig);
+	uint32_t token = mono_method_get_token (method);
+
+	char buf [128];
+	char *key = buf;
 	int len;
+	if (name != NULL) {
+		// the key must match the one used in PInvokeTableGenerator
+		len = snprintf (key, sizeof(buf), "%s#%d:%s:%s:%s", method_name, param_count, name, namespace, class_name);
 
-	assert (strlen (name) < 100);
-	snprintf (key, sizeof(key), "%s_%s_%s", name, class_name, method_name);
-	char *fixedName = mono_fixup_symbol_name ("", key, "");
-	addr = wasm_dl_get_native_to_interp (fixedName, extra_arg);
-	free (fixedName);
+		if (len >= sizeof (buf)) {
+			// The key is too long, try again with a larger buffer
+			key = g_new (char, len + 1);
+			snprintf (key, len + 1, "%s#%d:%s:%s:%s", method_name, param_count, name, namespace, class_name);
+		}
+
+		addr = wasm_dl_get_native_to_interp (token, key, extra_arg);
+
+		if (key != buf)
+			free (key);
+	}
 	MONO_EXIT_GC_UNSAFE;
 	return addr;
 }
 
-static void *sysglobal_native_handle;
+static void *sysglobal_native_handle = (void *)0xDeadBeef;
 
 static void*
 wasm_dl_load (const char *name, int flags, char **err, void *user_data)
@@ -248,24 +260,33 @@ wasm_dl_load (const char *name, int flags, char **err, void *user_data)
 	return NULL;
 }
 
+int
+import_compare_name (const void *k1, const void *k2)
+{
+	const PinvokeImport *e1 = (const PinvokeImport*)k1;
+	const PinvokeImport *e2 = (const PinvokeImport*)k2;
+
+	return strcmp (e1->name, e2->name);
+}
+
 static void*
 wasm_dl_symbol (void *handle, const char *name, char **err, void *user_data)
 {
-	if (handle == sysglobal_native_handle)
-		assert (0);
+	assert (handle != sysglobal_native_handle);
 
 #if WASM_SUPPORTS_DLOPEN
 	if (!wasm_dl_is_pinvoke_tables (handle)) {
 		return dlsym (handle, name);
 	}
 #endif
-
-	PinvokeImport *table = (PinvokeImport*)handle;
-	for (int i = 0; table [i].name; ++i) {
-		if (!strcmp (table [i].name, name))
-			return table [i].func;
-	}
-	return NULL;
+	PinvokeTable* index = (PinvokeTable*)handle;
+	PinvokeImport key = { name, NULL };
+    PinvokeImport* result = (PinvokeImport *)bsearch(&key, index->imports, index->count, sizeof(PinvokeImport), import_compare_name);
+    if (!result) {
+        // *err = g_strdup_printf ("Symbol not found: %s", name);
+        return NULL;
+    }
+    return result->func;
 }
 
 MonoDomain *
@@ -304,7 +325,7 @@ mono_wasm_load_runtime_common (int debug_level, MonoLogCallback log_callback, co
 	 */
 	if (debug_level) {
 		// Disable optimizations which interfere with debugging
-		interp_opts = "-all";
+		interp_opts = "-all,simd";
 		mono_wasm_enable_debugging (debug_level);
 	}
 #endif
@@ -363,6 +384,28 @@ mono_wasm_assembly_find_method (MonoClass *klass, const char *name, int argument
 	return result;
 }
 
+MonoMethod*
+mono_wasm_get_method_matching (MonoImage *image, uint32_t token, MonoClass *klass, const char* name, int param_count)
+{
+	MonoMethod *result = NULL;
+	MONO_ENTER_GC_UNSAFE;
+	MonoMethod *method = mono_get_method (image, token, klass);
+	MonoMethodSignature *sig = mono_method_signature (method);
+	// Lookp by token but verify the name and param count in case assembly was trimmed
+	if (mono_signature_get_param_count (sig) == param_count) {
+		const char *method_name = mono_method_get_name (method);
+		if (!strcmp (method_name, name)) {
+			result = method;
+		}
+	}
+	// If the token lookup failed, try to find the method by name and param count
+	if (!result) {
+		result = mono_class_get_method_from_name (klass, name, param_count);
+	}
+	MONO_EXIT_GC_UNSAFE;
+	return result;
+}
+
 /*
  * mono_wasm_marshal_get_managed_wrapper:
  * Creates a wrapper for a function pointer to a method marked with
@@ -370,17 +413,21 @@ mono_wasm_assembly_find_method (MonoClass *klass, const char *name, int argument
  * This wrapper ensures that the interpreter initializes the pointers.
  */
 void
-mono_wasm_marshal_get_managed_wrapper (const char* assemblyName, const char* namespaceName, const char* typeName, const char* methodName, int num_params)
+mono_wasm_marshal_get_managed_wrapper (const char* assemblyName, const char* namespaceName, const char* typeName, const char* methodName, uint32_t token, int param_count)
 {
 	MonoError error;
 	mono_error_init (&error);
+	MONO_ENTER_GC_UNSAFE;
 	MonoAssembly* assembly = mono_wasm_assembly_load (assemblyName);
 	assert (assembly);
-	MonoClass* class = mono_wasm_assembly_find_class (assembly, namespaceName, typeName);
-	assert (class);
-	MonoMethod* method = mono_wasm_assembly_find_method (class, methodName, num_params);
+	MonoImage *image = mono_assembly_get_image (assembly);
+	assert (image);
+	MonoClass* klass = mono_class_from_name (image, namespaceName, typeName);
+	assert (klass);
+	MonoMethod *method = mono_wasm_get_method_matching (image, token, klass, methodName, param_count);
 	assert (method);
 	MonoMethod *managedWrapper = mono_marshal_get_managed_wrapper (method, NULL, 0, &error);
 	assert (managedWrapper);
 	mono_compile_method (managedWrapper);
-}
+	MONO_EXIT_GC_UNSAFE;
+}

package/runtime.h

@@ -13,13 +13,11 @@
 #include <mono/metadata/object.h>
 #include <mono/metadata/debug-helpers.h>
 
-extern int mono_wasm_enable_gc;
-
 MonoDomain *mono_wasm_load_runtime_common (int debug_level, MonoLogCallback log_callback, const char *interp_opts);
 MonoAssembly *mono_wasm_assembly_load (const char *name);
 MonoClass *mono_wasm_assembly_find_class (MonoAssembly *assembly, const char *namespace, const char *name);
 MonoMethod *mono_wasm_assembly_find_method (MonoClass *klass, const char *name, int arguments);
-void mono_wasm_marshal_get_managed_wrapper (const char* assemblyName, const char* namespaceName, const char* typeName, const char* methodName, int num_params);
+void mono_wasm_marshal_get_managed_wrapper (const char* assemblyName, const char* namespaceName, const char* typeName, const char* methodName, uint32_t token, int param_count);
 int initialize_runtime ();
 
 #endif

package/wasm-props.json

@@ -6,7 +6,7 @@
       { "identity": "RuntimeEmccVersionHash", "value": "57b21b8fdcbe3ebb523178b79465254668eab408" }
     ],
     "WasmOptConfigurationFlags": [],
-    "EmccDefaultExportedFunctions": ["_free","_htons","_malloc","_sbrk","_memalign","_memset","_ntohs","stackAlloc","stackRestore","stackSave","_emscripten_force_exit","_fmod","_atan2","_fma","_pow","_fmodf","_atan2f","_fmaf","_powf","_asin","_asinh","_acos","_acosh","_atan","_atanh","_cbrt","_cos","_cosh","_exp","_log","_log2","_log10","_sin","_sinh","_tan","_tanh","_asinf","_asinhf","_acosf","_acoshf","_atanf","_atanhf","_cbrtf","_cosf","_coshf","_expf","_logf","_log2f","_log10f","_sinf","_sinhf","_tanf","_tanhf"],
+    "EmccDefaultExportedFunctions": ["_free","_htons","_malloc","_sbrk","_memalign","_posix_memalign","_memset","_ntohs","stackAlloc","stackRestore","stackSave","_emscripten_force_exit","_fmod","_atan2","_fma","_pow","_fmodf","_atan2f","_fmaf","_powf","_asin","_asinh","_acos","_acosh","_atan","_atanh","_cbrt","_cos","_cosh","_exp","_log","_log2","_log10","_sin","_sinh","_tan","_tanh","_asinf","_asinhf","_acosf","_acoshf","_atanf","_atanhf","_cbrtf","_cosf","_coshf","_expf","_logf","_log2f","_log10f","_sinf","_sinhf","_tanf","_tanhf"],
     "EmccDefaultExportedRuntimeMethods": ["FS","out","err","ccall","cwrap","setValue","getValue","UTF8ToString","UTF8ArrayToString","lengthBytesUTF8","stringToUTF8Array","FS_createPath","FS_createDataFile","removeRunDependency","addRunDependency","addFunction","safeSetTimeout","runtimeKeepalivePush","runtimeKeepalivePop","maybeExit","abort","wasmExports"],
     "PropertiesThatTriggerRelinking": [
       { "identity": "InvariantTimezone",            "defaultValueInRuntimePack": "false" },
@@ -15,7 +15,11 @@
       { "identity": "WasmSingleFileBundle",         "defaultValueInRuntimePack": "false" },
       { "identity": "WasmEnableSIMD",               "defaultValueInRuntimePack": "true" },
       { "identity": "WasmEnableExceptionHandling",  "defaultValueInRuntimePack": "true" },
-      { "identity": "EmccMaximumHeapSize",          "defaultValueInRuntimePack": "2147483648" }
+      { "identity": "EnableDiagnostics",            "defaultValueInRuntimePack": "false" },
+      { "identity": "WasmProfilers",                "defaultValueInRuntimePack": "" },
+      { "identity": "EmccMaximumHeapSize",          "defaultValueInRuntimePack": "2147483648" },
+      { "identity": "EmccInitialHeapSize",          "defaultValueInRuntimePack": "33554432" },
+      { "identity": "RunAOTCompilation",            "defaultValueInRuntimePack": "" }
     ]
   }
 }

package/PKHeX.runtimeconfig.json

@@ -1,41 +0,0 @@
-{
-  "runtimeOptions": {
-    "tfm": "net9.0",
-    "includedFrameworks": [
-      {
-        "name": "Microsoft.NETCore.App",
-        "version": "9.0.13"
-      }
-    ],
-    "configProperties": {
-      "Microsoft.Extensions.DependencyInjection.VerifyOpenGenericServiceTrimmability": true,
-      "System.ComponentModel.DefaultValueAttribute.IsSupported": false,
-      "System.ComponentModel.Design.IDesignerHost.IsSupported": false,
-      "System.ComponentModel.TypeConverter.EnableUnsafeBinaryFormatterInDesigntimeLicenseContextSerialization": false,
-      "System.ComponentModel.TypeDescriptor.IsComObjectDescriptorSupported": false,
-      "System.Diagnostics.Debugger.IsSupported": false,
-      "System.Diagnostics.Metrics.Meter.IsSupported": false,
-      "System.Diagnostics.Tracing.EventSource.IsSupported": false,
-      "System.Globalization.Invariant": true,
-      "System.TimeZoneInfo.Invariant": false,
-      "System.Globalization.PredefinedCulturesOnly": true,
-      "System.Linq.Enumerable.IsSizeOptimized": true,
-      "System.Net.Http.EnableActivityPropagation": false,
-      "System.Net.Http.WasmEnableStreamingResponse": true,
-      "System.Net.SocketsHttpHandler.Http3Support": false,
-      "System.Reflection.Metadata.MetadataUpdater.IsSupported": false,
-      "System.Resources.ResourceManager.AllowCustomResourceTypes": false,
-      "System.Resources.UseSystemResourceKeys": true,
-      "System.Runtime.CompilerServices.RuntimeFeature.IsDynamicCodeSupported": true,
-      "System.Runtime.InteropServices.BuiltInComInterop.IsSupported": false,
-      "System.Runtime.InteropServices.EnableConsumingManagedCodeFromNativeHosting": false,
-      "System.Runtime.InteropServices.EnableCppCLIHostActivation": false,
-      "System.Runtime.InteropServices.Marshalling.EnableGeneratedComInterfaceComImportInterop": false,
-      "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false,
-      "System.StartupHookProvider.IsSupported": false,
-      "System.Text.Encoding.EnableUnsafeUTF7Encoding": false,
-      "System.Text.Json.JsonSerializer.IsReflectionEnabledByDefault": false,
-      "System.Threading.Thread.EnableAutoreleasePool": false
-    }
-  }
-}