Add text and binary module types

core/modules/loaders.rs

@@ -79,6 +79,7 @@ pub trait ModuleLoader {
     _module_specifier: &ModuleSpecifier,
     _maybe_referrer: Option<String>,
     _is_dyn_import: bool,
+    _requested_module_type: RequestedModuleType,
   ) -> Pin<Box<dyn Future<Output = Result<(), Error>>>> {
     async { Ok(()) }.boxed_local()
   }
@@ -267,6 +268,7 @@ impl ModuleLoader for ExtModuleLoader {
     _specifier: &ModuleSpecifier,
     _maybe_referrer: Option<String>,
     _is_dyn_import: bool,
+    _requested_module_type: RequestedModuleType,
   ) -> Pin<Box<dyn Future<Output = Result<(), Error>>>> {
     async { Ok(()) }.boxed_local()
   }
@@ -322,6 +324,7 @@ impl ModuleLoader for LazyEsmModuleLoader {
     _specifier: &ModuleSpecifier,
     _maybe_referrer: Option<String>,
     _is_dyn_import: bool,
+    _requested_module_type: RequestedModuleType,
   ) -> Pin<Box<dyn Future<Output = Result<(), Error>>>> {
     async { Ok(()) }.boxed_local()
   }
@@ -516,11 +519,15 @@ impl<L: ModuleLoader> ModuleLoader for TestingModuleLoader<L> {
     module_specifier: &ModuleSpecifier,
     maybe_referrer: Option<String>,
     is_dyn_import: bool,
+    requested_module_type: RequestedModuleType,
   ) -> Pin<Box<dyn Future<Output = Result<(), Error>>>> {
     self.prepare_count.set(self.prepare_count.get() + 1);
-    self
-      .loader
-      .prepare_load(module_specifier, maybe_referrer, is_dyn_import)
+    self.loader.prepare_load(
+      module_specifier,
+      maybe_referrer,
+      is_dyn_import,
+      requested_module_type,
+    )
   }
 
   fn finish_load(&self) {

core/modules/map.rs

@@ -402,6 +402,18 @@ impl ModuleMap {
         let code = ModuleSource::get_string_source(code);
         self.new_json_module(scope, module_url_found, code)?
       }
+      ModuleType::Text => {
+        let code = ModuleSource::get_string_source(code);
+        self.new_text_module(scope, module_url_found, code)?
+      }
+      ModuleType::Binary => {
+        let ModuleSourceCode::Bytes(code) = code else {
+          return Err(ModuleError::Other(generic_error(
+            "Source code for Binary module must be provided as bytes",
+          )));
+        };
+        self.new_binary_module(scope, module_url_found, code)?
+      }
       ModuleType::Other(module_type) => {
         let state = JsRuntime::state_from(scope);
         let custom_module_evaluation_cb =
@@ -828,6 +840,52 @@ impl ModuleMap {
     self.new_synthetic_module(tc_scope, name, ModuleType::Json, exports)
   }
 
+  pub(crate) fn new_text_module(
+    &self,
+    scope: &mut v8::HandleScope,
+    name: impl IntoModuleName,
+    code: impl IntoModuleCodeString,
+  ) -> Result<ModuleId, ModuleError> {
+    let name = name.into_module_name();
+    let code = code.into_module_code();
+    let source_str = v8::String::new_from_utf8(
+      scope,
+      strip_bom(code.as_bytes()),
+      v8::NewStringType::Normal,
+    )
+    .unwrap();
+    let source_str_local = v8::Local::new(scope, source_str);
+    let source_value_local = v8::Local::<v8::Value>::from(source_str_local);
+    let exports = vec![(ascii_str!("default"), source_value_local)];
+    self.new_synthetic_module(scope, name, ModuleType::Text, exports)
+  }
+
+  pub(crate) fn new_binary_module(
+    &self,
+    scope: &mut v8::HandleScope,
+    name: impl IntoModuleName,
+    code: ModuleCodeBytes,
+  ) -> Result<ModuleId, ModuleError> {
+    let name = name.into_module_name();
+    let backing_store = match code {
+      // TODO: can we more efficiently reuse the existing storage with a future immutable arraybuffer variant?
+      ModuleCodeBytes::Static(bytes) => {
+        v8::ArrayBuffer::new_backing_store_from_vec(bytes.to_vec())
+      }
+      ModuleCodeBytes::Boxed(bytes) => {
+        v8::ArrayBuffer::new_backing_store_from_boxed_slice(bytes)
+      }
+      ModuleCodeBytes::Arc(bytes) => {
+        v8::ArrayBuffer::new_backing_store_from_vec(bytes.to_vec())
+      }
+    };
+    let source_arraybuffer =
+      v8::ArrayBuffer::with_backing_store(scope, &backing_store.make_shared());
+    let source_value_local = v8::Local::<v8::Value>::from(source_arraybuffer);
+    let exports = vec![(ascii_str!("default"), source_value_local)];
+    self.new_synthetic_module(scope, name, ModuleType::Binary, exports)
+  }
+
   pub(crate) fn instantiate_module(
     &self,
     scope: &mut v8::HandleScope,

core/modules/mod.rs

@@ -304,6 +304,8 @@ pub enum ModuleType {
   JavaScript,
   Wasm,
   Json,
+  Text,
+  Binary,
   Other(Cow<'static, str>),
 }
 
@@ -313,6 +315,8 @@ impl std::fmt::Display for ModuleType {
       Self::JavaScript => write!(f, "JavaScript"),
       Self::Wasm => write!(f, "Wasm"),
       Self::Json => write!(f, "JSON"),
+      Self::Text => write!(f, "Text"),
+      Self::Binary => write!(f, "Binary"),
       Self::Other(ty) => write!(f, "{}", ty),
     }
   }
@@ -327,6 +331,8 @@ impl ModuleType {
       ModuleType::JavaScript => v8::Integer::new(scope, 0).into(),
       ModuleType::Wasm => v8::Integer::new(scope, 1).into(),
       ModuleType::Json => v8::Integer::new(scope, 2).into(),
+      ModuleType::Text => v8::Integer::new(scope, 3).into(),
+      ModuleType::Binary => v8::Integer::new(scope, 4).into(),
       ModuleType::Other(ty) => v8::String::new(scope, ty).unwrap().into(),
     }
   }
@@ -340,6 +346,8 @@ impl ModuleType {
         0 => ModuleType::JavaScript,
         1 => ModuleType::Wasm,
         2 => ModuleType::Json,
+        3 => ModuleType::Text,
+        4 => ModuleType::Binary,
         _ => return None,
       }
     } else if let Ok(str) = v8::Local::<v8::String>::try_from(value) {
@@ -511,7 +519,7 @@ pub enum RequestedModuleType {
   /// ```ignore
   /// import jsonData from "./data.json" with { type: "json" };
   ///
-  /// const jsonData2 = await import"./data2.json", { with { type: "json" } });
+  /// const jsonData2 = await import("./data2.json", { with { type: "json" } });
   /// ```
   Json,
 
@@ -558,6 +566,14 @@ impl RequestedModuleType {
       return None;
     })
   }
+
+  pub fn as_str(&self) -> Option<&str> {
+    match self {
+      RequestedModuleType::None => None,
+      RequestedModuleType::Json => Some("json"),
+      RequestedModuleType::Other(ty) => Some(ty),
+    }
+  }
 }
 
 impl AsRef<RequestedModuleType> for RequestedModuleType {
@@ -573,6 +589,12 @@ impl PartialEq<ModuleType> for RequestedModuleType {
       ModuleType::JavaScript => self == &RequestedModuleType::None,
       ModuleType::Wasm => self == &RequestedModuleType::None,
       ModuleType::Json => self == &RequestedModuleType::Json,
+      ModuleType::Text => {
+        self == &RequestedModuleType::Other(Cow::Borrowed("text"))
+      }
+      ModuleType::Binary => {
+        self == &RequestedModuleType::Other(Cow::Borrowed("binary"))
+      }
       ModuleType::Other(ty) => self == &RequestedModuleType::Other(ty.clone()),
     }
   }
@@ -584,6 +606,8 @@ impl From<ModuleType> for RequestedModuleType {
       ModuleType::JavaScript => RequestedModuleType::None,
       ModuleType::Wasm => RequestedModuleType::None,
       ModuleType::Json => RequestedModuleType::Json,
+      ModuleType::Text => RequestedModuleType::Other(Cow::Borrowed("text")),
+      ModuleType::Binary => RequestedModuleType::Other(Cow::Borrowed("binary")),
       ModuleType::Other(ty) => RequestedModuleType::Other(ty.clone()),
     }
   }

core/modules/recursive_load.rs

@@ -150,35 +150,50 @@ impl RecursiveModuleLoad {
   }
 
   pub(crate) async fn prepare(&self) -> Result<(), Error> {
-    let (module_specifier, maybe_referrer) = match self.init {
+    let (module_specifier, maybe_referrer, requested_module_type) = match self
+      .init
+    {
       LoadInit::Main(ref specifier) => {
         let spec = self.module_map_rc.resolve(
           specifier,
           ".",
           ResolutionKind::MainModule,
         )?;
-        (spec, None)
+        (spec, None, RequestedModuleType::None)
       }
       LoadInit::Side(ref specifier) => {
         let spec =
           self
             .module_map_rc
             .resolve(specifier, ".", ResolutionKind::Import)?;
-        (spec, None)
+        (spec, None, RequestedModuleType::None)
       }
-      LoadInit::DynamicImport(ref specifier, ref referrer, _) => {
+      LoadInit::DynamicImport(
+        ref specifier,
+        ref referrer,
+        ref requested_module_type,
+      ) => {
         let spec = self.module_map_rc.resolve(
           specifier,
           referrer,
           ResolutionKind::DynamicImport,
         )?;
-        (spec, Some(referrer.to_string()))
+        (
+          spec,
+          Some(referrer.to_string()),
+          requested_module_type.clone(),
+        )
       }
     };
 
     self
       .loader
-      .prepare_load(&module_specifier, maybe_referrer, self.is_dynamic_import())
+      .prepare_load(
+        &module_specifier,
+        maybe_referrer,
+        self.is_dynamic_import(),
+        requested_module_type,
+      )
       .await
   }