From 9a20976a588a96cbf598cbd4408a5ed0f3a9536f Mon Sep 17 00:00:00 2001
From: RedYetiDev <38299977+RedYetiDev@users.noreply.github.com>
Date: Thu, 29 Aug 2024 17:30:49 -0400
Subject: [PATCH 1/3] module: support `import()`-ing `blob:` urls

---
 doc/api/esm.md                         | 34 +++++++++++--
 lib/internal/modules/esm/get_format.js | 10 +++-
 lib/internal/modules/esm/load.js       |  9 +++-
 test/es-module/test-esm-blob-urls.js   | 68 ++++++++++++++++++++++++++
 4 files changed, 115 insertions(+), 6 deletions(-)
 create mode 100644 test/es-module/test-esm-blob-urls.js

diff --git a/doc/api/esm.md b/doc/api/esm.md
index d1215b3caf5..09179951abe 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -189,7 +189,7 @@ typically configured server.
 ES modules are resolved and cached as URLs. This means that special characters
 must be [percent-encoded][], such as `#` with `%23` and `?` with `%3F`.
 
-`file:`, `node:`, and `data:` URL schemes are supported. A specifier like
+`file:`, `node:`, `data:`, and `blob:` URL schemes are supported. A specifier like
 `'https://example.com/app.js'` is not supported natively in Node.js unless using
 a [custom HTTPS loader][].
 
@@ -231,6 +231,34 @@ and [absolute specifiers][Terminology]. Resolving
 from `data:text/javascript,import "./foo";` fails to resolve because there
 is no concept of relative resolution for `data:` URLs.
 
+#### `blob:` imports
+
+<!-- YAML
+added: REPLACEME
+-->
+
+`blob:` URLs are supported for importing with the following MIME types:
+
+* `text/javascript` for ES modules
+* `application/json` for JSON
+* `application/wasm` for Wasm
+
+Blob URLs are registered within the current thread. Loaders will not be
+able to handle resolve Blob's from the main thread.
+
+```mjs
+import { Blob } from 'node:buffer';
+
+const mjs = new Blob(['export "Hello, World!"'], { type: 'text/javascript' });
+await import(URL.createObjectURL(mjs));
+
+const json = new Blob(['{}'], { type: 'application/json' });
+await import(URL.createObjectURL(json), { with: { type: 'json' } });
+
+const wasm = new Blob(['WASM Data'], { type: 'application/wasm' });
+await import(URL.createObjectURL(wasm));
+```
+
 #### `node:` imports
 
 <!-- YAML
@@ -721,7 +749,7 @@ The default resolver has the following properties:
 The default loader has the following properties
 
 * Support for builtin module loading via `node:` URLs
-* Support for "inline" module loading via `data:` URLs
+* Support for "inline" module loading via `data:` and `blob:` URLs
 * Support for `file:` module loading
 * Fails on any other URL protocol
 * Fails on unknown extensions for `file:` loading
@@ -739,7 +767,7 @@ does not determine whether the resolved URL protocol can be loaded,
 or whether the file extensions are permitted, instead these validations
 are applied by Node.js during the load phase
 (for example, if it was asked to load a URL that has a protocol that is
-not `file:`, `data:` or `node:`.
+not `file:`, `data:`, `blob:`, or `node:`).
 
 The algorithm also tries to determine the format of the file based
 on the extension (see `ESM_FILE_FORMAT` algorithm below). If it does
diff --git a/lib/internal/modules/esm/get_format.js b/lib/internal/modules/esm/get_format.js
index 0eedf2a7288..fa5d435943b 100644
--- a/lib/internal/modules/esm/get_format.js
+++ b/lib/internal/modules/esm/get_format.js
@@ -17,14 +17,16 @@ const {
 
 const detectModule = getOptionValue('--experimental-detect-module');
 const { containsModuleSyntax } = internalBinding('contextify');
+const { resolveObjectURL } = require('buffer');
 const { getPackageScopeConfig, getPackageType } = require('internal/modules/package_json_reader');
 const { fileURLToPath } = require('internal/url');
-const { ERR_UNKNOWN_FILE_EXTENSION } = require('internal/errors').codes;
+const { ERR_UNKNOWN_FILE_EXTENSION, ERR_INVALID_URL } = require('internal/errors').codes;
 
 const protocolHandlers = {
   '__proto__': null,
   'data:': getDataProtocolModuleFormat,
   'file:': getFileProtocolModuleFormat,
+  'blob:': getBlobProtocolModuleFormat,
   'node:'() { return 'builtin'; },
 };
 
@@ -218,6 +220,12 @@ function getFileProtocolModuleFormat(url, context = { __proto__: null }, ignoreE
   throw new ERR_UNKNOWN_FILE_EXTENSION(ext, filepath);
 }
 
+function getBlobProtocolModuleFormat(url, context = { __proto__: null }, ignoreErrors) {
+  const blob = resolveObjectURL(url);
+  if (blob === undefined) { throw new ERR_INVALID_URL(blob); }
+  return mimeToFormat(blob.type);
+}
+
 /**
  * @param {URL} url
  * @param {{parentURL: string}} context
diff --git a/lib/internal/modules/esm/load.js b/lib/internal/modules/esm/load.js
index e82f7715e7a..278375844ed 100644
--- a/lib/internal/modules/esm/load.js
+++ b/lib/internal/modules/esm/load.js
@@ -14,7 +14,7 @@ const { readFileSync } = require('fs');
 const defaultType =
   getOptionValue('--experimental-default-type');
 
-const { Buffer: { from: BufferFrom } } = require('buffer');
+const { Buffer: { from: BufferFrom }, resolveObjectURL } = require('buffer');
 const {
   isUnderNodeModules,
 } = require('internal/modules/helpers');
@@ -48,8 +48,12 @@ async function getSource(url, context) {
     }
     const { 1: base64, 2: body } = match;
     source = BufferFrom(decodeURIComponent(body), base64 ? 'base64' : 'utf8');
+  } else if (protocol === 'blob:') {
+    const blob = resolveObjectURL(url);
+    if (blob === undefined) { throw new ERR_INVALID_URL(blob); }
+    source = await blob.text();
   } else {
-    const supportedSchemes = ['file', 'data'];
+    const supportedSchemes = ['file', 'data', 'blob'];
     throw new ERR_UNSUPPORTED_ESM_URL_SCHEME(url, supportedSchemes);
   }
   return { __proto__: null, responseURL, source };
@@ -219,6 +223,7 @@ function throwIfUnsupportedURLScheme(parsed) {
     protocol !== 'file:' &&
     protocol !== 'data:' &&
     protocol !== 'node:' &&
+    protocol !== 'blob:' &&
     (
       protocol !== 'https:' &&
       protocol !== 'http:'
diff --git a/test/es-module/test-esm-blob-urls.js b/test/es-module/test-esm-blob-urls.js
new file mode 100644
index 00000000000..c774f6f5648
--- /dev/null
+++ b/test/es-module/test-esm-blob-urls.js
@@ -0,0 +1,68 @@
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const { test } = require('node:test');
+
+if (!common.hasCrypto) common.skip('missing crypto');
+
+async function createURL(mime, body) {
+  const blob = new Blob([body], { type: mime });
+  return URL.createObjectURL(blob);
+}
+
+function createBase64URL(mime, body) {
+  return `data:${mime};base64,${Buffer.from(body).toString('base64')}`;
+}
+
+test('importing JavaScript from a Blob: URL should work', async (t) => {
+  const url = await createURL('text/javascript', 'export default { "key": "value" }');
+  const { default: expected } = await import(url);
+  t.assert.deepStrictEqual(expected, { key: 'value' });
+});
+
+test('import.meta.url should be equal to the blob URL', async (t) => {
+  const url = await createURL('text/javascript', 'export default import.meta.url;');
+  const { default: expected } = await import(url);
+  t.assert.deepStrictEqual(expected, url);
+});
+
+
+test('importing JSON from a Blob: URL should work', async (t) => {
+  const url = await createURL('application/json', '{ "key": "value" }');
+  const { default: expected } = await import(url, { with: { type: 'json' } });
+  t.assert.deepStrictEqual(expected, { key: 'value' });
+});
+
+test('importing a module from within a blob: URL should work', async (t) => {
+  await t.test('file: URLs', async (t) => {
+    const url = await createURL('text/javascript', `import { message } from ${JSON.stringify(fixtures.fileURL('es-modules/message.mjs'))}; export default message;`);
+    const { default: expected } = await import(url);
+    t.assert.strictEqual(expected, 'A message');
+  });
+
+  await t.test('data: URLs', async (t) => {
+    const dataURL = createBase64URL('text/javascript', 'export const message = "Base64 Imported";');
+    const url = await createURL('text/javascript', `import { message } from "${dataURL}"; export default message;`);
+    const { default: expected } = await import(url);
+    t.assert.strictEqual(expected, 'Base64 Imported');
+  });
+
+  await t.test('blob: URLs', async (t) => {
+    const url = await createURL('text/javascript',
+                                `const blob = new Blob(["export default 'Blob Imported'"], { type: 'application/javascript' });` +
+      'const url = URL.createObjectURL(blob);' +
+      'export default await import(url);'
+    );
+    const { default: { default: expected } } = await import(url);
+    t.assert.strictEqual(expected, 'Blob Imported');
+  });
+});
+
+test('importing a disallowed mimetype should fail', async (t) => {
+  const url = await createURL('invalid/mime', '');
+  await t.assert.rejects(import(url), /ERR_UNKNOWN_MODULE_FORMAT/);
+});
+
+test('importing an invalid blob should fail', async (t) => {
+  await t.assert.rejects(import('blob:nodedata:123456'), /ERR_INVALID_URL/);
+});

From c55442d59487540ed5755e390284f77444bc0ca9 Mon Sep 17 00:00:00 2001
From: Aviv Keller <redyetidev@gmail.com>
Date: Sun, 1 Sep 2024 14:12:57 -0400
Subject: [PATCH 2/3] mark experimental

---
 doc/api/esm.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/doc/api/esm.md b/doc/api/esm.md
index 09179951abe..08d135bdc6a 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -237,6 +237,8 @@ is no concept of relative resolution for `data:` URLs.
 added: REPLACEME
 -->
 
+> Stability: 1 - Experimental
+
 `blob:` URLs are supported for importing with the following MIME types:
 
 * `text/javascript` for ES modules

From b57674ee8f69cc2a54df0a8795ecd53263ace60e Mon Sep 17 00:00:00 2001
From: Aviv Keller <redyetidev@gmail.com>
Date: Sun, 1 Sep 2024 14:14:39 -0400
Subject: [PATCH 3/3] Update esm.md

---
 doc/api/esm.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/esm.md b/doc/api/esm.md
index 08d135bdc6a..98e7b501415 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -246,7 +246,7 @@ added: REPLACEME
 * `application/wasm` for Wasm
 
 Blob URLs are registered within the current thread. Loaders will not be
-able to handle resolve Blob's from the main thread.
+able to resolve Blob URLs created from the main thread.
 
 ```mjs
 import { Blob } from 'node:buffer';