feat(compile): ability to embed local data files (#26934)

```
> deno compile --allow-read=. --include data-file.txt main.js
```

This only applies to files on the filesystem. For remote modules, that's
going to have to wait for `import ... from "./data.txt" with { "type":
"bytes" }` or whatever it will be.

1 files changed, 62 insertions, 18 deletions

diff --git a/cli/tools/compile.rs b/cli/tools/compile.rs
index b3e999337..4fa996368 100644
--- a/cli/tools/compile.rs
+++ b/cli/tools/compile.rs
@@ -7,6 +7,7 @@ use crate::factory::CliFactory;
 use crate::http_util::HttpClientProvider;
 use crate::standalone::binary::StandaloneRelativeFileBaseUrl;
 use crate::standalone::is_standalone_binary;
+use deno_ast::MediaType;
 use deno_ast::ModuleSpecifier;
 use deno_core::anyhow::bail;
 use deno_core::anyhow::Context;
@@ -31,15 +32,12 @@ pub async fn compile(
   let module_graph_creator = factory.module_graph_creator().await?;
   let binary_writer = factory.create_compile_binary_writer().await?;
   let http_client = factory.http_client_provider();
-  let module_specifier = cli_options.resolve_main_module()?;
-  let module_roots = {
-    let mut vec = Vec::with_capacity(compile_flags.include.len() + 1);
-    vec.push(module_specifier.clone());
-    for side_module in &compile_flags.include {
-      vec.push(resolve_url_or_path(side_module, cli_options.initial_cwd())?);
-    }
-    vec
-  };
+  let entrypoint = cli_options.resolve_main_module()?;
+  let (module_roots, include_files) = get_module_roots_and_include_files(
+    entrypoint,
+    &compile_flags,
+    cli_options.initial_cwd(),
+  )?;
 
   // this is not supported, so show a warning about it, but don't error in order
   // to allow someone to still run `deno compile` when this is in a deno.json
@@ -82,18 +80,22 @@ pub async fn compile(
   check_warn_tsconfig(&ts_config_for_emit);
   let root_dir_url = resolve_root_dir_from_specifiers(
     cli_options.workspace().root_dir(),
-    graph.specifiers().map(|(s, _)| s).chain(
-      cli_options
-        .node_modules_dir_path()
-        .and_then(|p| ModuleSpecifier::from_directory_path(p).ok())
-        .iter(),
-    ),
+    graph
+      .specifiers()
+      .map(|(s, _)| s)
+      .chain(
+        cli_options
+          .node_modules_dir_path()
+          .and_then(|p| ModuleSpecifier::from_directory_path(p).ok())
+          .iter(),
+      )
+      .chain(include_files.iter()),
   );
   log::debug!("Binary root dir: {}", root_dir_url);
   log::info!(
     "{} {} to {}",
     colors::green("Compile"),
-    module_specifier.to_string(),
+    entrypoint,
     output_path.display(),
   );
   validate_output_path(&output_path)?;
@@ -118,9 +120,9 @@ pub async fn compile(
       file,
       &graph,
       StandaloneRelativeFileBaseUrl::from(&root_dir_url),
-      module_specifier,
+      entrypoint,
+      &include_files,
       &compile_flags,
-      cli_options,
     )
     .await
     .with_context(|| {
@@ -212,6 +214,48 @@ fn validate_output_path(output_path: &Path) -> Result<(), AnyError> {
   Ok(())
 }
 
+fn get_module_roots_and_include_files(
+  entrypoint: &ModuleSpecifier,
+  compile_flags: &CompileFlags,
+  initial_cwd: &Path,
+) -> Result<(Vec<ModuleSpecifier>, Vec<ModuleSpecifier>), AnyError> {
+  fn is_module_graph_module(url: &ModuleSpecifier) -> bool {
+    if url.scheme() != "file" {
+      return true;
+    }
+    let media_type = MediaType::from_specifier(url);
+    match media_type {
+      MediaType::JavaScript
+      | MediaType::Jsx
+      | MediaType::Mjs
+      | MediaType::Cjs
+      | MediaType::TypeScript
+      | MediaType::Mts
+      | MediaType::Cts
+      | MediaType::Dts
+      | MediaType::Dmts
+      | MediaType::Dcts
+      | MediaType::Tsx
+      | MediaType::Json
+      | MediaType::Wasm => true,
+      MediaType::Css | MediaType::SourceMap | MediaType::Unknown => false,
+    }
+  }
+
+  let mut module_roots = Vec::with_capacity(compile_flags.include.len() + 1);
+  let mut include_files = Vec::with_capacity(compile_flags.include.len());
+  module_roots.push(entrypoint.clone());
+  for side_module in &compile_flags.include {
+    let url = resolve_url_or_path(side_module, initial_cwd)?;
+    if is_module_graph_module(&url) {
+      module_roots.push(url);
+    } else {
+      include_files.push(url);
+    }
+  }
+  Ok((module_roots, include_files))
+}
+
 async fn resolve_compile_executable_output_path(
   http_client_provider: &HttpClientProvider,
   compile_flags: &CompileFlags,