diff --git a/src/jsc/NodeModuleModule.rs b/src/jsc/NodeModuleModule.rs index 473818c587e9..b3e5fcf2ecb5 100644 --- a/src/jsc/NodeModuleModule.rs +++ b/src/jsc/NodeModuleModule.rs @@ -228,21 +228,35 @@ fn on_require_extension_modify_non_function( Ok(()) } +/// Default keys of `Module._extensions` (see `JSCommonJSExtensions::finishCreation`). +const EXTENSIONS_DEFAULT_KEYS: &[&[u8]] = &[ + b".js", b".json", b".node", b".ts", b".cts", b".mjs", b".mts", +]; + pub fn find_longest_registered_extension<'a>( vm: &'a VirtualMachine, filename: &[u8], ) -> Option<&'a CustomLoader> { let basename = bun_paths::basename(filename); let mut next: usize = 0; + let mut last_ext: &[u8] = b""; while let Some(i) = strings::index_of_char_pos(basename, b'.', next) { next = i + 1; if i == 0 { continue; } let ext = &basename[i..]; + last_ext = ext; if let Some(value) = vm.commonjs_custom_extensions.get(ext) { return Some(value); } + if EXTENSIONS_DEFAULT_KEYS.iter().any(|k| *k == ext) { + return None; + } + } + // Node's `.js` fallback; skip for extensions Bun handles natively (e.g. `.jsx`). + if last_ext == b".cjs" || DEFAULT_LOADERS.get(last_ext).is_none() { + return vm.commonjs_custom_extensions.get(b".js".as_slice()); } None } diff --git a/src/jsc/bindings/JSCommonJSModule.cpp b/src/jsc/bindings/JSCommonJSModule.cpp index e18cc0c15b55..a5873c619cfd 100644 --- a/src/jsc/bindings/JSCommonJSModule.cpp +++ b/src/jsc/bindings/JSCommonJSModule.cpp @@ -235,16 +235,24 @@ static bool evaluateCommonJSModuleOnce(JSC::VM& vm, Zig::GlobalObject* globalObj bool JSCommonJSModule::load(JSC::VM& vm, Zig::GlobalObject* globalObject) { auto scope = DECLARE_THROW_SCOPE(vm); - if (this->hasEvaluated || this->sourceCode.isNull()) { + if (this->hasEvaluated) { return true; } - evaluateCommonJSModuleOnce( - globalObject->vm(), - globalObject, - this, - this->m_dirname.get(), - this->m_filename.get()); + if (JSValue extension = this->m_pendingCustomExtension.get()) { + this->m_pendingCustomExtension.clear(); + evaluateCommonJSCustomExtension(globalObject, this, this->m_filename.get(), extension); + this->hasEvaluated = true; + } else if (this->sourceCode.isNull()) { + return true; + } else { + evaluateCommonJSModuleOnce( + globalObject->vm(), + globalObject, + this, + this->m_dirname.get(), + this->m_filename.get()); + } if (auto exception = scope.exception()) { (void)scope.tryClearException(); @@ -1189,6 +1197,7 @@ void JSCommonJSModule::visitChildrenImpl(JSCell* cell, Visitor& visitor) visitor.appendHidden(thisObject->m_paths); visitor.appendHidden(thisObject->m_overriddenParent); visitor.appendHidden(thisObject->m_overriddenCompile); + visitor.appendHidden(thisObject->m_pendingCustomExtension); visitor.appendHidden(thisObject->m_childrenValue); { WTF::Locker locker { thisObject->cellLock() }; @@ -1551,12 +1560,22 @@ static JSC::SourceCode commonJSModuleSyntheticSourceCode(const SourceOrigin& sou if (entry) { if (auto* moduleObject = dynamicDowncast(entry)) { if (!moduleObject->hasEvaluated) { - evaluateCommonJSModuleOnce( - vm, - globalObject, - moduleObject, - moduleObject->m_dirname.get(), - moduleObject->m_filename.get()); + if (JSValue extension = moduleObject->m_pendingCustomExtension.get()) { + moduleObject->m_pendingCustomExtension.clear(); + evaluateCommonJSCustomExtension( + globalObject, + moduleObject, + moduleObject->m_filename.get(), + extension); + moduleObject->hasEvaluated = true; + } else { + evaluateCommonJSModuleOnce( + vm, + globalObject, + moduleObject, + moduleObject->m_dirname.get(), + moduleObject->m_filename.get()); + } if (auto exception = scope.exception()) { (void)scope.tryClearException(); @@ -1581,58 +1600,89 @@ static JSC::SourceCode commonJSModuleSyntheticSourceCode(const SourceOrigin& sou sourceURL)); } -std::optional createCommonJSModule( +static JSCommonJSModule* getOrCreateCommonJSModule( Zig::GlobalObject* globalObject, JSC::JSString* requireMapKey, - Ref&& sourceProvider, - bool ignoreESModuleAnnotation) + const WTF::String& sourceURL, + JSC::SourceCode&& sourceCode) { auto& vm = JSC::getVM(globalObject); auto scope = DECLARE_THROW_SCOPE(vm); - JSCommonJSModule* moduleObject = nullptr; - WTF::String sourceURL = sourceProvider->sourceURL(); - SourceOrigin sourceOrigin = sourceProvider->sourceOrigin(); JSValue entry = globalObject->requireMap()->get(globalObject, requireMapKey); - RETURN_IF_EXCEPTION(scope, {}); - + RETURN_IF_EXCEPTION(scope, nullptr); if (entry) { - moduleObject = dynamicDowncast(entry); + if (auto* moduleObject = dynamicDowncast(entry)) + return moduleObject; } - if (!moduleObject) { - size_t index = sourceURL.reverseFind(PLATFORM_SEP, sourceURL.length()); - JSString* dirname; - JSString* filename = requireMapKey; - if (index != WTF::notFound) { - dirname = JSC::jsSubstring(globalObject, requireMapKey, 0, index); - RETURN_IF_EXCEPTION(scope, {}); - } else { - dirname = jsEmptyString(vm); - } - auto requireMap = globalObject->requireMap(); - if (requireMap->size() == 0) { - requireMapKey = JSC::jsString(vm, WTF::String("."_s)); - } + size_t index = sourceURL.reverseFind(PLATFORM_SEP, sourceURL.length()); + JSString* dirname; + JSString* filename = requireMapKey; + if (index != WTF::notFound) { + dirname = JSC::jsSubstring(globalObject, requireMapKey, 0, index); + RETURN_IF_EXCEPTION(scope, nullptr); + } else { + dirname = jsEmptyString(vm); + } + auto requireMap = globalObject->requireMap(); + if (requireMap->size() == 0) { + requireMapKey = JSC::jsString(vm, WTF::String("."_s)); + } - moduleObject = JSCommonJSModule::create( - vm, - globalObject->CommonJSModuleObjectStructure(), - requireMapKey, filename, dirname, JSC::SourceCode(WTF::move(sourceProvider))); + auto* moduleObject = JSCommonJSModule::create( + vm, + globalObject->CommonJSModuleObjectStructure(), + requireMapKey, filename, dirname, WTF::move(sourceCode)); - moduleObject->putDirect(vm, - WebCore::clientData(vm)->builtinNames().exportsPublicName(), - JSC::constructEmptyObject(globalObject, globalObject->objectPrototype()), 0); + moduleObject->putDirect(vm, + WebCore::clientData(vm)->builtinNames().exportsPublicName(), + JSC::constructEmptyObject(globalObject, globalObject->objectPrototype()), 0); - requireMap->set(globalObject, filename, moduleObject); - RETURN_IF_EXCEPTION(scope, {}); - } + requireMap->set(globalObject, filename, moduleObject); + RETURN_IF_EXCEPTION(scope, nullptr); + return moduleObject; +} +std::optional createCommonJSModule( + Zig::GlobalObject* globalObject, + JSC::JSString* requireMapKey, + Ref&& sourceProvider, + bool ignoreESModuleAnnotation) +{ + auto& vm = JSC::getVM(globalObject); + auto scope = DECLARE_THROW_SCOPE(vm); + WTF::String sourceURL = sourceProvider->sourceURL(); + SourceOrigin sourceOrigin = sourceProvider->sourceOrigin(); + + auto* moduleObject = getOrCreateCommonJSModule( + globalObject, requireMapKey, sourceURL, JSC::SourceCode(WTF::move(sourceProvider))); + RETURN_IF_EXCEPTION(scope, {}); moduleObject->ignoreESModuleAnnotation = ignoreESModuleAnnotation; return commonJSModuleSyntheticSourceCode(sourceOrigin, sourceURL); } +std::optional createCommonJSModuleForCustomExtension( + Zig::GlobalObject* globalObject, + JSC::JSString* requireMapKey, + JSC::JSValue extension) +{ + auto& vm = JSC::getVM(globalObject); + auto scope = DECLARE_THROW_SCOPE(vm); + WTF::String sourceURL = requireMapKey->value(globalObject); + RETURN_IF_EXCEPTION(scope, {}); + SourceOrigin sourceOrigin = Zig::toSourceOrigin(sourceURL, false); + + auto* moduleObject = getOrCreateCommonJSModule( + globalObject, requireMapKey, sourceURL, JSC::SourceCode()); + RETURN_IF_EXCEPTION(scope, {}); + if (!moduleObject->hasEvaluated) + moduleObject->m_pendingCustomExtension.set(vm, moduleObject, extension); + + return commonJSModuleSyntheticSourceCode(sourceOrigin, sourceURL); +} + JSObject* JSCommonJSModule::createBoundRequireFunction(VM& vm, JSGlobalObject* lexicalGlobalObject, const WTF::String& pathString) { ASSERT(!pathString.startsWith("file://"_s)); diff --git a/src/jsc/bindings/JSCommonJSModule.h b/src/jsc/bindings/JSCommonJSModule.h index eb7bf713307a..722c4fe073a1 100644 --- a/src/jsc/bindings/JSCommonJSModule.h +++ b/src/jsc/bindings/JSCommonJSModule.h @@ -70,6 +70,8 @@ class JSCommonJSModule final : public JSC::JSDestructibleObject { // If compile is overridden, it is assigned to this field. The default // compile function is not stored here, but in mutable JSC::WriteBarrier m_overriddenCompile; + // `Module._extensions` handler to invoke at deferred synthetic-module eval time. + mutable JSC::WriteBarrier m_pendingCustomExtension; bool ignoreESModuleAnnotation { false }; JSC::SourceCode sourceCode = JSC::SourceCode(); @@ -184,6 +186,11 @@ inline std::optional createCommonJSModule( return createCommonJSModule(globalObject, specifierValue, source, false); } +std::optional createCommonJSModuleForCustomExtension( + Zig::GlobalObject* globalObject, + JSC::JSString* specifierValue, + JSC::JSValue extension); + class RequireResolveFunctionPrototype final : public JSC::JSNonFinalObject { public: using Base = JSC::JSNonFinalObject; diff --git a/src/jsc/bindings/ModuleLoader.cpp b/src/jsc/bindings/ModuleLoader.cpp index 7c5ba80bb6a3..d1075032729b 100644 --- a/src/jsc/bindings/ModuleLoader.cpp +++ b/src/jsc/bindings/ModuleLoader.cpp @@ -616,7 +616,6 @@ JSValue resolveAndFetchBuiltinModule( void evaluateCommonJSCustomExtension( Zig::GlobalObject* globalObject, JSCommonJSModule* target, - String filename, JSValue filenameValue, JSValue extension) { @@ -864,7 +863,7 @@ JSValue fetchCommonJSModuleNonBuiltin( JSC::throwException(globalObject, scope, JSC::createSyntaxError(globalObject, "Recursive extension. This is a bug in Bun"_s)); RELEASE_AND_RETURN(scope, {}); } - evaluateCommonJSCustomExtension(globalObject, target, specifierWtfString, specifierValue, JSC::JSValue::decode(res->result.value.cjsCustomExtension)); + evaluateCommonJSCustomExtension(globalObject, target, specifierValue, JSC::JSValue::decode(res->result.value.cjsCustomExtension)); RETURN_IF_EXCEPTION(scope, {}); RELEASE_AND_RETURN(scope, target); } @@ -1114,6 +1113,24 @@ static JSValue fetchESMSourceCode( RELEASE_AND_RETURN(scope, reject(exception)); } + if (res->result.value.tag == SyntheticModuleType::CommonJSCustomExtension) { + auto created = Bun::createCommonJSModuleForCustomExtension( + globalObject, specifierJS, JSC::JSValue::decode(res->result.value.cjsCustomExtension)); + EXCEPTION_ASSERT(created.has_value() == !scope.exception()); + if (created.has_value()) { + RELEASE_AND_RETURN(scope, rejectOrResolve(JSSourceCode::create(vm, WTF::move(created.value())))); + } + + if constexpr (allowPromise) { + auto* exception = scope.exception(); + (void)scope.tryClearException(); + RELEASE_AND_RETURN(scope, rejectedInternalPromise(globalObject, exception)); + } else { + scope.release(); + return {}; + } + } + // The JSONForObjectLoader tag is source code returned from Bun that needs // to go through the JSON parser in JSC. // diff --git a/src/jsc/bindings/ModuleLoader.h b/src/jsc/bindings/ModuleLoader.h index 5f8380c67242..563845b8176c 100644 --- a/src/jsc/bindings/ModuleLoader.h +++ b/src/jsc/bindings/ModuleLoader.h @@ -139,4 +139,10 @@ JSValue fetchBuiltinModuleWithoutResolution( BunString* specifier, ErrorableResolvedSource* res); +void evaluateCommonJSCustomExtension( + Zig::GlobalObject* globalObject, + JSCommonJSModule* target, + JSValue filenameValue, + JSValue extension); + } // namespace Bun diff --git a/src/runtime/jsc_hooks.rs b/src/runtime/jsc_hooks.rs index 0c719212132e..6ce05d776f14 100644 --- a/src/runtime/jsc_hooks.rs +++ b/src/runtime/jsc_hooks.rs @@ -4229,19 +4229,50 @@ unsafe fn transpile_file( } }); + // ── module_type sniff from extension / package.json ───────────────────── + let module_type: ModuleType = 'brk: { + let ext = lr.path.name().ext; + // regex /\.[cm][jt]s$/ + if ext.len() == b".cjs".len() { + if ext == b".cjs" { + break 'brk ModuleType::Cjs; + } + if ext == b".mjs" { + break 'brk ModuleType::Esm; + } + if ext == b".cts" { + break 'brk ModuleType::Cjs; + } + if ext == b".mts" { + break 'brk ModuleType::Esm; + } + } + // regex /\.[jt]s$/ + if ext.len() == b".ts".len() && (ext == b".js" || ext == b".ts") { + // Use the package.json module type if it exists. + break 'brk lr + .package_json + .map(|pkg| pkg.module_type) + .unwrap_or(ModuleType::Unknown); + } + // For JSX/TSX and other extensions, let the file contents decide. + ModuleType::Unknown + }; + // ── force_loader / require.extensions override ────────────────────────── if let Some(loader_type) = force_loader_type { // Note: `@branchHint(.unlikely)` dropped (no stable Rust equiv). debug_assert!(!is_commonjs_require); lr.loader = Some(loader_type); - } else if is_commonjs_require + } else if (is_commonjs_require || module_type == ModuleType::Cjs) + && lr.virtual_source.is_none() // SAFETY: per fn contract. && unsafe { &*jsc_vm }.has_mutated_built_in_extensions > 0 { use bun_jsc::node_module_module::{CustomLoader, find_longest_registered_extension}; if let Some(entry) = // SAFETY: per fn contract. - find_longest_registered_extension(unsafe { &*jsc_vm }, _specifier.slice()) + find_longest_registered_extension(unsafe { &*jsc_vm }, lr.path.text) { match entry { CustomLoader::Loader(loader) => lr.loader = Some(*loader), @@ -4262,36 +4293,6 @@ unsafe fn transpile_file( } } } - - // ── module_type sniff from extension / package.json ───────────────────── - let module_type: ModuleType = 'brk: { - let ext = lr.path.name().ext; - // regex /\.[cm][jt]s$/ - if ext.len() == b".cjs".len() { - if ext == b".cjs" { - break 'brk ModuleType::Cjs; - } - if ext == b".mjs" { - break 'brk ModuleType::Esm; - } - if ext == b".cts" { - break 'brk ModuleType::Cjs; - } - if ext == b".mts" { - break 'brk ModuleType::Esm; - } - } - // regex /\.[jt]s$/ - if ext.len() == b".ts".len() && (ext == b".js" || ext == b".ts") { - // Use the package.json module type if it exists. - break 'brk lr - .package_json - .map(|pkg| pkg.module_type) - .unwrap_or(ModuleType::Unknown); - } - // For JSX/TSX and other extensions, let the file contents decide. - ModuleType::Unknown - }; let pkg_name: Option<&[u8]> = lr .package_json .and_then(|pkg| (!pkg.name.is_empty()).then_some(&*pkg.name)); diff --git a/test/js/node/module/require-extensions-entrypoint-esm.test.ts b/test/js/node/module/require-extensions-entrypoint-esm.test.ts new file mode 100644 index 000000000000..97e424e62ace --- /dev/null +++ b/test/js/node/module/require-extensions-entrypoint-esm.test.ts @@ -0,0 +1,174 @@ +import { describe, expect, test } from "bun:test"; +import { bunEnv, bunExe, tempDir } from "harness"; + +// Node.js routes every CJS-loader load (the entrypoint, a CJS module reached +// from ESM import, and nested require()) through Module._extensions, so a +// `-r` preload hook like babel-register or pirates sees all of them. +describe.concurrent("Module._extensions fires for the CJS entrypoint and CJS reached via ESM import", () => { + const hook = ` +const M = require("module"), path = require("path"), oe = M._extensions[".js"]; +globalThis.__hits = []; +M._extensions[".js"] = function (m, f) { globalThis.__hits.push(path.basename(f)); return oe(m, f); }; +`; + + test("CJS entrypoint and nested require hit the overridden .js handler", async () => { + using dir = tempDir("ext-entry", { + "package.json": '{"type":"commonjs"}', + "hook.cjs": hook, + "dep.js": "module.exports = 1;", + "dep2.cjs": "module.exports = 2;", + "main.js": 'require("./dep.js"); require("./dep2.cjs"); console.log(JSON.stringify(globalThis.__hits));', + }); + await using proc = Bun.spawn({ + cmd: [bunExe(), "-r", "./hook.cjs", "main.js"], + env: bunEnv, + cwd: String(dir), + stderr: "pipe", + }); + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + expect(stderr).toBe(""); + // Node's findLongestRegisteredExtension falls back to ".js" for .cjs. + expect(stdout.trim()).toBe('["main.js","dep.js","dep2.cjs"]'); + expect(exitCode).toBe(0); + }); + + test(".cjs entrypoint falls back to the overridden .js handler", async () => { + using dir = tempDir("ext-entry-cjs", { + "package.json": '{"type":"commonjs"}', + "hook.cjs": hook, + "dep.js": "module.exports = 1;", + "main.cjs": 'require("./dep.js"); console.log(JSON.stringify(globalThis.__hits));', + }); + await using proc = Bun.spawn({ + cmd: [bunExe(), "-r", "./hook.cjs", "main.cjs"], + env: bunEnv, + cwd: String(dir), + stderr: "pipe", + }); + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + expect(stderr).toBe(""); + expect(stdout.trim()).toBe('["main.cjs","dep.js"]'); + expect(exitCode).toBe(0); + }); + + test("ESM import of a CJS module hits the overridden .js handler", async () => { + using dir = tempDir("ext-esm-import", { + "package.json": '{"type":"commonjs"}', + "hook.cjs": hook, + "dep.js": "module.exports = 1;", + "dep2.cjs": "module.exports = 2;", + "main.mjs": + 'await import("./dep.js"); await import("./dep2.cjs"); console.log(JSON.stringify(globalThis.__hits));', + }); + await using proc = Bun.spawn({ + cmd: [bunExe(), "-r", "./hook.cjs", "main.mjs"], + env: bunEnv, + cwd: String(dir), + stderr: "pipe", + }); + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + expect(stderr).toBe(""); + expect(stdout.trim()).toBe('["dep.js","dep2.cjs"]'); + expect(exitCode).toBe(0); + }); + + test("ESM import of an ESM .js module does NOT hit the overridden .js handler", async () => { + using dir = tempDir("ext-esm-esm", { + "package.json": '{"type":"module"}', + "hook.cjs": hook, + "dep.js": "export const x = 1;", + "main.js": 'import "./dep.js"; console.log(JSON.stringify(globalThis.__hits));', + }); + await using proc = Bun.spawn({ + cmd: [bunExe(), "-r", "./hook.cjs", "main.js"], + env: bunEnv, + cwd: String(dir), + stderr: "pipe", + }); + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + expect(stderr).toBe(""); + expect(stdout.trim()).toBe("[]"); + expect(exitCode).toBe(0); + }); + + test("ESM import of an auto-detected ESM .js (no package.json type) still works with a passthrough .js override", async () => { + using dir = tempDir("ext-nopkg-esm", { + "hook.cjs": ` +const M = require("module"), oe = M._extensions[".js"]; +M._extensions[".js"] = (m, f) => oe(m, f); +`, + "foo.js": "export const x = 42;", + "main.mjs": 'import { x } from "./foo.js"; console.log("x=" + x);', + }); + await using proc = Bun.spawn({ + cmd: [bunExe(), "-r", "./hook.cjs", "main.mjs"], + env: bunEnv, + cwd: String(dir), + stderr: "pipe", + }); + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + expect(stderr).toBe(""); + expect(stdout.trim()).toBe("x=42"); + expect(exitCode).toBe(0); + }); + + test("require() of a sibling CJS module already fetched (but not yet evaluated) by the ESM loader runs its extension handler", async () => { + using dir = tempDir("ext-cross-require", { + "package.json": '{"type":"commonjs"}', + "hook.cjs": ` +const M = require("module"), fs = require("fs"); +M._extensions[".js"] = (m, f) => m._compile(fs.readFileSync(f, "utf8"), f); +`, + "a.js": 'module.exports = { fromB: require("./b.js").value };', + "b.js": "module.exports = { value: 42 };", + "main.mjs": 'import a from "./a.js"; import "./b.js"; console.log(JSON.stringify({ fromB: a.fromB }));', + }); + await using proc = Bun.spawn({ + cmd: [bunExe(), "-r", "./hook.cjs", "main.mjs"], + env: bunEnv, + cwd: String(dir), + stderr: "pipe", + }); + const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); + expect(stderr).toBe(""); + expect(stdout.trim()).toBe('{"fromB":42}'); + expect(exitCode).toBe(0); + }); + + test("a preload hook that transforms source applies to the CJS entrypoint and CJS via ESM import", async () => { + using dir = tempDir("ext-transform", { + "package.json": '{"type":"commonjs"}', + "hook.cjs": ` +const M = require("module"), fs = require("fs"); +M._extensions[".js"] = function (m, f) { + m._compile(fs.readFileSync(f, "utf8").replace(/REPLACE_ME/g, '"xform"'), f); +}; +`, + "dep.js": 'module.exports = { value: REPLACE_ME, nested: require("./dep2.js") };', + "dep2.js": 'module.exports = REPLACE_ME + "2";', + "main.js": 'console.log(JSON.stringify({ entry: REPLACE_ME, nested: require("./dep2.js") }));', + "main.mjs": 'import dep from "./dep.js"; console.log(JSON.stringify(dep));', + }); + await using p1 = Bun.spawn({ + cmd: [bunExe(), "-r", "./hook.cjs", "main.js"], + env: bunEnv, + cwd: String(dir), + stderr: "pipe", + }); + const [out1, err1, code1] = await Promise.all([p1.stdout.text(), p1.stderr.text(), p1.exited]); + expect(err1).toBe(""); + expect(out1.trim()).toBe('{"entry":"xform","nested":"xform2"}'); + expect(code1).toBe(0); + + await using p2 = Bun.spawn({ + cmd: [bunExe(), "-r", "./hook.cjs", "main.mjs"], + env: bunEnv, + cwd: String(dir), + stderr: "pipe", + }); + const [out2, err2, code2] = await Promise.all([p2.stdout.text(), p2.stderr.text(), p2.exited]); + expect(err2).toBe(""); + expect(out2.trim()).toBe('{"value":"xform","nested":"xform2"}'); + expect(code2).toBe(0); + }); +});