refactor: use deno_graph's semver and npm structs (#17791)

13 files changed, 26 insertions, 516 deletions

diff --git a/cli/npm/cache.rs b/cli/npm/cache.rs
index 888975926..a602feb57 100644
--- a/cli/npm/cache.rs
+++ b/cli/npm/cache.rs
@@ -13,11 +13,11 @@ use deno_core::error::custom_error;
 use deno_core::error::AnyError;
 use deno_core::parking_lot::Mutex;
 use deno_core::url::Url;
+use deno_graph::semver::Version;
 
 use crate::args::CacheSetting;
 use crate::cache::DenoDir;
 use crate::http_util::HttpClient;
-use crate::semver::Version;
 use crate::util::fs::canonicalize_path;
 use crate::util::fs::hard_link_dir_recursive;
 use crate::util::path::root_url_to_safe_local_dirname;
@@ -514,10 +514,10 @@ pub fn mixed_case_package_name_decode(name: &str) -> Option<String> {
 #[cfg(test)]
 mod test {
   use deno_core::url::Url;
+  use deno_graph::semver::Version;
 
   use super::ReadonlyNpmCache;
   use crate::npm::cache::NpmPackageCacheFolderId;
-  use crate::semver::Version;
 
   #[test]
   fn should_get_package_folder() {
diff --git a/cli/npm/mod.rs b/cli/npm/mod.rs
index b9a4f493a..7fdf57fbf 100644
--- a/cli/npm/mod.rs
+++ b/cli/npm/mod.rs
@@ -12,9 +12,6 @@ pub use registry::NpmPackageVersionDistInfo;
 pub use registry::NpmRegistryApi;
 pub use registry::RealNpmRegistryApi;
 pub use resolution::resolve_graph_npm_info;
-pub use resolution::NpmPackageId;
-pub use resolution::NpmPackageReference;
-pub use resolution::NpmPackageReq;
 pub use resolution::NpmResolutionPackage;
 pub use resolution::NpmResolutionSnapshot;
 pub use resolvers::NpmPackageResolver;
diff --git a/cli/npm/registry.rs b/cli/npm/registry.rs
index fea6996ab..d267d2224 100644
--- a/cli/npm/registry.rs
+++ b/cli/npm/registry.rs
@@ -19,14 +19,14 @@ use deno_core::parking_lot::Mutex;
 use deno_core::serde::Deserialize;
 use deno_core::serde_json;
 use deno_core::url::Url;
+use deno_graph::semver::Version;
+use deno_graph::semver::VersionReq;
 use deno_runtime::colors;
 use serde::Serialize;
 
 use crate::args::CacheSetting;
 use crate::cache::CACHE_PERM;
 use crate::http_util::HttpClient;
-use crate::semver::Version;
-use crate::semver::VersionReq;
 use crate::util::fs::atomic_write_file;
 use crate::util::progress_bar::ProgressBar;
 
diff --git a/cli/npm/resolution/graph.rs b/cli/npm/resolution/graph.rs
index 20f192fbf..2f102746a 100644
--- a/cli/npm/resolution/graph.rs
+++ b/cli/npm/resolution/graph.rs
@@ -13,6 +13,10 @@ use deno_core::error::AnyError;
 use deno_core::futures;
 use deno_core::parking_lot::Mutex;
 use deno_core::parking_lot::MutexGuard;
+use deno_graph::npm::NpmPackageId;
+use deno_graph::npm::NpmPackageReq;
+use deno_graph::semver::Version;
+use deno_graph::semver::VersionReq;
 use log::debug;
 use once_cell::sync::Lazy;
 
@@ -22,13 +26,9 @@ use crate::npm::registry::NpmDependencyEntryKind;
 use crate::npm::registry::NpmPackageInfo;
 use crate::npm::registry::NpmPackageVersionInfo;
 use crate::npm::NpmRegistryApi;
-use crate::semver::Version;
-use crate::semver::VersionReq;
 
 use super::snapshot::NpmResolutionSnapshot;
 use super::snapshot::SnapshotPackageCopyIndexResolver;
-use super::NpmPackageId;
-use super::NpmPackageReq;
 use super::NpmResolutionPackage;
 
 pub static LATEST_VERSION_REQ: Lazy<VersionReq> =
@@ -1113,10 +1113,10 @@ fn tag_to_version_info<'a>(
 
 #[cfg(test)]
 mod test {
+  use deno_graph::npm::NpmPackageReference;
   use pretty_assertions::assert_eq;
 
   use crate::npm::registry::TestNpmRegistryApi;
-  use crate::npm::NpmPackageReference;
 
   use super::*;
 
diff --git a/cli/npm/resolution/mod.rs b/cli/npm/resolution/mod.rs
index 990ad8d06..0f6dcb910 100644
--- a/cli/npm/resolution/mod.rs
+++ b/cli/npm/resolution/mod.rs
@@ -3,15 +3,15 @@
 use std::collections::HashMap;
 use std::collections::HashSet;
 
-use deno_core::anyhow::Context;
 use deno_core::error::AnyError;
 use deno_core::futures;
 use deno_core::parking_lot::RwLock;
+use deno_graph::npm::NpmPackageId;
+use deno_graph::npm::NpmPackageReq;
 use serde::Deserialize;
 use serde::Serialize;
 
 use crate::args::Lockfile;
-use crate::semver::Version;
 
 use self::graph::GraphDependencyResolver;
 use self::snapshot::NpmPackagesPartitioned;
@@ -23,157 +23,13 @@ use super::registry::RealNpmRegistryApi;
 use super::NpmRegistryApi;
 
 mod graph;
-mod reference;
 mod snapshot;
 mod specifier;
 
 use graph::Graph;
-pub use reference::NpmPackageReference;
-pub use reference::NpmPackageReq;
 pub use snapshot::NpmResolutionSnapshot;
 pub use specifier::resolve_graph_npm_info;
 
-#[derive(
-  Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash, Serialize, Deserialize,
-)]
-pub struct NpmPackageId {
-  pub name: String,
-  pub version: Version,
-  pub peer_dependencies: Vec<NpmPackageId>,
-}
-
-impl NpmPackageId {
-  #[allow(unused)]
-  pub fn scope(&self) -> Option<&str> {
-    if self.name.starts_with('@') && self.name.contains('/') {
-      self.name.split('/').next()
-    } else {
-      None
-    }
-  }
-
-  pub fn as_serialized(&self) -> String {
-    self.as_serialized_with_level(0)
-  }
-
-  fn as_serialized_with_level(&self, level: usize) -> String {
-    // WARNING: This should not change because it's used in the lockfile
-    let mut result = format!(
-      "{}@{}",
-      if level == 0 {
-        self.name.to_string()
-      } else {
-        self.name.replace('/', "+")
-      },
-      self.version
-    );
-    for peer in &self.peer_dependencies {
-      // unfortunately we can't do something like `_3` when
-      // this gets deep because npm package names can start
-      // with a number
-      result.push_str(&"_".repeat(level + 1));
-      result.push_str(&peer.as_serialized_with_level(level + 1));
-    }
-    result
-  }
-
-  pub fn from_serialized(id: &str) -> Result<Self, AnyError> {
-    use monch::*;
-
-    fn parse_name(input: &str) -> ParseResult<&str> {
-      if_not_empty(substring(move |input| {
-        for (pos, c) in input.char_indices() {
-          // first character might be a scope, so skip it
-          if pos > 0 && c == '@' {
-            return Ok((&input[pos..], ()));
-          }
-        }
-        ParseError::backtrace()
-      }))(input)
-    }
-
-    fn parse_version(input: &str) -> ParseResult<&str> {
-      if_not_empty(substring(skip_while(|c| c != '_')))(input)
-    }
-
-    fn parse_name_and_version(input: &str) -> ParseResult<(String, Version)> {
-      let (input, name) = parse_name(input)?;
-      let (input, _) = ch('@')(input)?;
-      let at_version_input = input;
-      let (input, version) = parse_version(input)?;
-      match Version::parse_from_npm(version) {
-        Ok(version) => Ok((input, (name.to_string(), version))),
-        Err(err) => ParseError::fail(at_version_input, format!("{err:#}")),
-      }
-    }
-
-    fn parse_level_at_level<'a>(
-      level: usize,
-    ) -> impl Fn(&'a str) -> ParseResult<'a, ()> {
-      fn parse_level(input: &str) -> ParseResult<usize> {
-        let level = input.chars().take_while(|c| *c == '_').count();
-        Ok((&input[level..], level))
-      }
-
-      move |input| {
-        let (input, parsed_level) = parse_level(input)?;
-        if parsed_level == level {
-          Ok((input, ()))
-        } else {
-          ParseError::backtrace()
-        }
-      }
-    }
-
-    fn parse_peers_at_level<'a>(
-      level: usize,
-    ) -> impl Fn(&'a str) -> ParseResult<'a, Vec<NpmPackageId>> {
-      move |mut input| {
-        let mut peers = Vec::new();
-        while let Ok((level_input, _)) = parse_level_at_level(level)(input) {
-          input = level_input;
-          let peer_result = parse_id_at_level(level)(input)?;
-          input = peer_result.0;
-          peers.push(peer_result.1);
-        }
-        Ok((input, peers))
-      }
-    }
-
-    fn parse_id_at_level<'a>(
-      level: usize,
-    ) -> impl Fn(&'a str) -> ParseResult<'a, NpmPackageId> {
-      move |input| {
-        let (input, (name, version)) = parse_name_and_version(input)?;
-        let name = if level > 0 {
-          name.replace('+', "/")
-        } else {
-          name
-        };
-        let (input, peer_dependencies) =
-          parse_peers_at_level(level + 1)(input)?;
-        Ok((
-          input,
-          NpmPackageId {
-            name,
-            version,
-            peer_dependencies,
-          },
-        ))
-      }
-    }
-
-    with_failure_handling(parse_id_at_level(0))(id)
-      .with_context(|| format!("Invalid npm package id '{id}'."))
-  }
-
-  pub fn display(&self) -> String {
-    // Don't implement std::fmt::Display because we don't
-    // want this to be used by accident in certain scenarios.
-    format!("{}@{}", self.name, self.version)
-  }
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct NpmResolutionPackage {
   pub id: NpmPackageId,
@@ -399,46 +255,3 @@ impl NpmResolution {
     Ok(())
   }
 }
-
-#[cfg(test)]
-mod tests {
-  use super::*;
-
-  #[test]
-  fn serialize_npm_package_id() {
-    let id = NpmPackageId {
-      name: "pkg-a".to_string(),
-      version: Version::parse_from_npm("1.2.3").unwrap(),
-      peer_dependencies: vec![
-        NpmPackageId {
-          name: "pkg-b".to_string(),
-          version: Version::parse_from_npm("3.2.1").unwrap(),
-          peer_dependencies: vec![
-            NpmPackageId {
-              name: "pkg-c".to_string(),
-              version: Version::parse_from_npm("1.3.2").unwrap(),
-              peer_dependencies: vec![],
-            },
-            NpmPackageId {
-              name: "pkg-d".to_string(),
-              version: Version::parse_from_npm("2.3.4").unwrap(),
-              peer_dependencies: vec![],
-            },
-          ],
-        },
-        NpmPackageId {
-          name: "pkg-e".to_string(),
-          version: Version::parse_from_npm("2.3.1").unwrap(),
-          peer_dependencies: vec![NpmPackageId {
-            name: "pkg-f".to_string(),
-            version: Version::parse_from_npm("2.3.1").unwrap(),
-            peer_dependencies: vec![],
-          }],
-        },
-      ],
-    };
-    let serialized = id.as_serialized();
-    assert_eq!(serialized, "pkg-a@1.2.3_pkg-b@3.2.1__pkg-c@1.3.2__pkg-d@2.3.4_pkg-e@2.3.1__pkg-f@2.3.1");
-    assert_eq!(NpmPackageId::from_serialized(&serialized).unwrap(), id);
-  }
-}
diff --git a/cli/npm/resolution/reference.rs b/cli/npm/resolution/reference.rs
deleted file mode 100644
index 2d34bcc34..000000000
--- a/cli/npm/resolution/reference.rs
+++ /dev/null
@@ -1,298 +0,0 @@
-// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-
-use deno_ast::ModuleSpecifier;
-use deno_core::anyhow::bail;
-use deno_core::anyhow::Context;
-use deno_core::error::generic_error;
-use deno_core::error::AnyError;
-use serde::Deserialize;
-use serde::Serialize;
-
-use crate::semver::VersionReq;
-
-/// A reference to an npm package's name, version constraint, and potential sub path.
-///
-/// This contains all the information found in an npm specifier.
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
-pub struct NpmPackageReference {
-  pub req: NpmPackageReq,
-  pub sub_path: Option<String>,
-}
-
-impl NpmPackageReference {
-  pub fn from_specifier(
-    specifier: &ModuleSpecifier,
-  ) -> Result<NpmPackageReference, AnyError> {
-    Self::from_str(specifier.as_str())
-  }
-
-  pub fn from_str(specifier: &str) -> Result<NpmPackageReference, AnyError> {
-    let original_text = specifier;
-    let specifier = match specifier.strip_prefix("npm:") {
-      Some(s) => {
-        // Strip leading slash, which might come from import map
-        s.strip_prefix('/').unwrap_or(s)
-      }
-      None => {
-        // don't allocate a string here and instead use a static string
-        // because this is hit a lot when a url is not an npm specifier
-        return Err(generic_error("Not an npm specifier"));
-      }
-    };
-    let parts = specifier.split('/').collect::<Vec<_>>();
-    let name_part_len = if specifier.starts_with('@') { 2 } else { 1 };
-    if parts.len() < name_part_len {
-      return Err(generic_error(format!("Not a valid package: {specifier}")));
-    }
-    let name_parts = &parts[0..name_part_len];
-    let req = match NpmPackageReq::parse_from_parts(name_parts) {
-      Ok(pkg_req) => pkg_req,
-      Err(err) => {
-        return Err(generic_error(format!(
-          "Invalid npm specifier '{original_text}'. {err:#}"
-        )))
-      }
-    };
-    let sub_path = if parts.len() == name_parts.len() {
-      None
-    } else {
-      let sub_path = parts[name_part_len..].join("/");
-      if sub_path.is_empty() {
-        None
-      } else {
-        Some(sub_path)
-      }
-    };
-
-    if let Some(sub_path) = &sub_path {
-      if let Some(at_index) = sub_path.rfind('@') {
-        let (new_sub_path, version) = sub_path.split_at(at_index);
-        let msg = format!(
-          "Invalid package specifier 'npm:{req}/{sub_path}'. Did you mean to write 'npm:{req}{version}/{new_sub_path}'?"
-        );
-        return Err(generic_error(msg));
-      }
-    }
-
-    Ok(NpmPackageReference { req, sub_path })
-  }
-}
-
-impl std::fmt::Display for NpmPackageReference {
-  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    if let Some(sub_path) = &self.sub_path {
-      write!(f, "npm:{}/{}", self.req, sub_path)
-    } else {
-      write!(f, "npm:{}", self.req)
-    }
-  }
-}
-
-/// The name and version constraint component of an `NpmPackageReference`.
-#[derive(
-  Clone, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize,
-)]
-pub struct NpmPackageReq {
-  pub name: String,
-  pub version_req: Option<VersionReq>,
-}
-
-impl std::fmt::Display for NpmPackageReq {
-  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    match &self.version_req {
-      Some(req) => write!(f, "{}@{}", self.name, req),
-      None => write!(f, "{}", self.name),
-    }
-  }
-}
-
-impl NpmPackageReq {
-  pub fn from_str(text: &str) -> Result<Self, AnyError> {
-    let parts = text.split('/').collect::<Vec<_>>();
-    match NpmPackageReq::parse_from_parts(&parts) {
-      Ok(req) => Ok(req),
-      Err(err) => {
-        let msg = format!("Invalid npm package requirement '{text}'. {err:#}");
-        Err(generic_error(msg))
-      }
-    }
-  }
-
-  fn parse_from_parts(name_parts: &[&str]) -> Result<Self, AnyError> {
-    assert!(!name_parts.is_empty()); // this should be provided the result of a string split
-    let last_name_part = &name_parts[name_parts.len() - 1];
-    let (name, version_req) = if let Some(at_index) = last_name_part.rfind('@')
-    {
-      let version = &last_name_part[at_index + 1..];
-      let last_name_part = &last_name_part[..at_index];
-      let version_req = VersionReq::parse_from_specifier(version)
-        .with_context(|| "Invalid version requirement.")?;
-      let name = if name_parts.len() == 1 {
-        last_name_part.to_string()
-      } else {
-        format!("{}/{}", name_parts[0], last_name_part)
-      };
-      (name, Some(version_req))
-    } else {
-      (name_parts.join("/"), None)
-    };
-    if name.is_empty() {
-      bail!("Did not contain a package name.")
-    }
-    Ok(Self { name, version_req })
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use pretty_assertions::assert_eq;
-
-  use super::*;
-
-  #[test]
-  fn parse_npm_package_ref() {
-    assert_eq!(
-      NpmPackageReference::from_str("npm:@package/test").unwrap(),
-      NpmPackageReference {
-        req: NpmPackageReq {
-          name: "@package/test".to_string(),
-          version_req: None,
-        },
-        sub_path: None,
-      }
-    );
-
-    assert_eq!(
-      NpmPackageReference::from_str("npm:@package/test@1").unwrap(),
-      NpmPackageReference {
-        req: NpmPackageReq {
-          name: "@package/test".to_string(),
-          version_req: Some(VersionReq::parse_from_specifier("1").unwrap()),
-        },
-        sub_path: None,
-      }
-    );
-
-    assert_eq!(
-      NpmPackageReference::from_str("npm:@package/test@~1.1/sub_path").unwrap(),
-      NpmPackageReference {
-        req: NpmPackageReq {
-          name: "@package/test".to_string(),
-          version_req: Some(VersionReq::parse_from_specifier("~1.1").unwrap()),
-        },
-        sub_path: Some("sub_path".to_string()),
-      }
-    );
-
-    assert_eq!(
-      NpmPackageReference::from_str("npm:@package/test/sub_path").unwrap(),
-      NpmPackageReference {
-        req: NpmPackageReq {
-          name: "@package/test".to_string(),
-          version_req: None,
-        },
-        sub_path: Some("sub_path".to_string()),
-      }
-    );
-
-    assert_eq!(
-      NpmPackageReference::from_str("npm:test").unwrap(),
-      NpmPackageReference {
-        req: NpmPackageReq {
-          name: "test".to_string(),
-          version_req: None,
-        },
-        sub_path: None,
-      }
-    );
-
-    assert_eq!(
-      NpmPackageReference::from_str("npm:test@^1.2").unwrap(),
-      NpmPackageReference {
-        req: NpmPackageReq {
-          name: "test".to_string(),
-          version_req: Some(VersionReq::parse_from_specifier("^1.2").unwrap()),
-        },
-        sub_path: None,
-      }
-    );
-
-    assert_eq!(
-      NpmPackageReference::from_str("npm:test@~1.1/sub_path").unwrap(),
-      NpmPackageReference {
-        req: NpmPackageReq {
-          name: "test".to_string(),
-          version_req: Some(VersionReq::parse_from_specifier("~1.1").unwrap()),
-        },
-        sub_path: Some("sub_path".to_string()),
-      }
-    );
-
-    assert_eq!(
-      NpmPackageReference::from_str("npm:@package/test/sub_path").unwrap(),
-      NpmPackageReference {
-        req: NpmPackageReq {
-          name: "@package/test".to_string(),
-          version_req: None,
-        },
-        sub_path: Some("sub_path".to_string()),
-      }
-    );
-
-    assert_eq!(
-      NpmPackageReference::from_str("npm:@package")
-        .err()
-        .unwrap()
-        .to_string(),
-      "Not a valid package: @package"
-    );
-
-    // should parse leading slash
-    assert_eq!(
-      NpmPackageReference::from_str("npm:/@package/test/sub_path").unwrap(),
-      NpmPackageReference {
-        req: NpmPackageReq {
-          name: "@package/test".to_string(),
-          version_req: None,
-        },
-        sub_path: Some("sub_path".to_string()),
-      }
-    );
-    assert_eq!(
-      NpmPackageReference::from_str("npm:/test").unwrap(),
-      NpmPackageReference {
-        req: NpmPackageReq {
-          name: "test".to_string(),
-          version_req: None,
-        },
-        sub_path: None,
-      }
-    );
-    assert_eq!(
-      NpmPackageReference::from_str("npm:/test/").unwrap(),
-      NpmPackageReference {
-        req: NpmPackageReq {
-          name: "test".to_string(),
-          version_req: None,
-        },
-        sub_path: None,
-      }
-    );
-
-    // should error for no name
-    assert_eq!(
-      NpmPackageReference::from_str("npm:/")
-        .err()
-        .unwrap()
-        .to_string(),
-      "Invalid npm specifier 'npm:/'. Did not contain a package name."
-    );
-    assert_eq!(
-      NpmPackageReference::from_str("npm://test")
-        .err()
-        .unwrap()
-        .to_string(),
-      "Invalid npm specifier 'npm://test'. Did not contain a package name."
-    );
-  }
-}
diff --git a/cli/npm/resolution/snapshot.rs b/cli/npm/resolution/snapshot.rs
index 934320a1d..957f5d6d8 100644
--- a/cli/npm/resolution/snapshot.rs
+++ b/cli/npm/resolution/snapshot.rs
@@ -10,6 +10,9 @@ use deno_core::anyhow::Context;
 use deno_core::error::AnyError;
 use deno_core::futures;
 use deno_core::parking_lot::Mutex;
+use deno_graph::npm::NpmPackageId;
+use deno_graph::npm::NpmPackageReq;
+use deno_graph::semver::VersionReq;
 use serde::Deserialize;
 use serde::Serialize;
 
@@ -19,10 +22,7 @@ use crate::npm::cache::NpmPackageCacheFolderId;
 use crate::npm::registry::NpmPackageVersionDistInfo;
 use crate::npm::registry::NpmRegistryApi;
 use crate::npm::registry::RealNpmRegistryApi;
-use crate::semver::VersionReq;
 
-use super::NpmPackageId;
-use super::NpmPackageReq;
 use super::NpmResolutionPackage;
 
 /// Packages partitioned by if they are "copy" packages or not.
diff --git a/cli/npm/resolution/specifier.rs b/cli/npm/resolution/specifier.rs
index 0f1491f0d..36d93bca4 100644
--- a/cli/npm/resolution/specifier.rs
+++ b/cli/npm/resolution/specifier.rs
@@ -6,13 +6,11 @@ use std::collections::HashSet;
 use std::collections::VecDeque;
 
 use deno_ast::ModuleSpecifier;
+use deno_graph::npm::NpmPackageReference;
+use deno_graph::npm::NpmPackageReq;
+use deno_graph::semver::VersionReq;
 use deno_graph::ModuleGraph;
 
-use crate::semver::VersionReq;
-
-use super::NpmPackageReference;
-use super::NpmPackageReq;
-
 pub struct GraphNpmInfo {
   /// The order of these package requirements is the order they
   /// should be resolved in.
diff --git a/cli/npm/resolvers/common.rs b/cli/npm/resolvers/common.rs
index 7fe9c3fa4..99af7352b 100644
--- a/cli/npm/resolvers/common.rs
+++ b/cli/npm/resolvers/common.rs
@@ -10,6 +10,8 @@ use deno_core::error::AnyError;
 use deno_core::futures;
 use deno_core::futures::future::BoxFuture;
 use deno_core::url::Url;
+use deno_graph::npm::NpmPackageId;
+use deno_graph::npm::NpmPackageReq;
 use deno_runtime::deno_node::NodePermissions;
 use deno_runtime::deno_node::NodeResolutionMode;
 
@@ -17,8 +19,6 @@ use crate::args::Lockfile;
 use crate::npm::cache::should_sync_download;
 use crate::npm::resolution::NpmResolutionSnapshot;
 use crate::npm::NpmCache;
-use crate::npm::NpmPackageId;
-use crate::npm::NpmPackageReq;
 use crate::npm::NpmResolutionPackage;
 
 pub trait InnerNpmPackageResolver: Send + Sync {
diff --git a/cli/npm/resolvers/global.rs b/cli/npm/resolvers/global.rs
index 41a1329ec..bc358fee2 100644
--- a/cli/npm/resolvers/global.rs
+++ b/cli/npm/resolvers/global.rs
@@ -12,6 +12,8 @@ use deno_core::error::AnyError;
 use deno_core::futures::future::BoxFuture;
 use deno_core::futures::FutureExt;
 use deno_core::url::Url;
+use deno_graph::npm::NpmPackageId;
+use deno_graph::npm::NpmPackageReq;
 use deno_runtime::deno_node::NodePermissions;
 use deno_runtime::deno_node::NodeResolutionMode;
 
@@ -21,8 +23,6 @@ use crate::npm::resolution::NpmResolution;
 use crate::npm::resolution::NpmResolutionSnapshot;
 use crate::npm::resolvers::common::cache_packages;
 use crate::npm::NpmCache;
-use crate::npm::NpmPackageId;
-use crate::npm::NpmPackageReq;
 use crate::npm::NpmResolutionPackage;
 use crate::npm::RealNpmRegistryApi;
 
diff --git a/cli/npm/resolvers/local.rs b/cli/npm/resolvers/local.rs
index 7c1f38b47..dab367f3d 100644
--- a/cli/npm/resolvers/local.rs
+++ b/cli/npm/resolvers/local.rs
@@ -18,6 +18,8 @@ use deno_core::error::AnyError;
 use deno_core::futures::future::BoxFuture;
 use deno_core::futures::FutureExt;
 use deno_core::url::Url;
+use deno_graph::npm::NpmPackageId;
+use deno_graph::npm::NpmPackageReq;
 use deno_runtime::deno_core::futures;
 use deno_runtime::deno_node::NodePermissions;
 use deno_runtime::deno_node::NodeResolutionMode;
@@ -31,8 +33,6 @@ use crate::npm::cache::NpmPackageCacheFolderId;
 use crate::npm::resolution::NpmResolution;
 use crate::npm::resolution::NpmResolutionSnapshot;
 use crate::npm::NpmCache;
-use crate::npm::NpmPackageId;
-use crate::npm::NpmPackageReq;
 use crate::npm::NpmResolutionPackage;
 use crate::npm::RealNpmRegistryApi;
 use crate::util::fs::copy_dir_recursive;
diff --git a/cli/npm/resolvers/mod.rs b/cli/npm/resolvers/mod.rs
index 9ea14061e..31c6c0b05 100644
--- a/cli/npm/resolvers/mod.rs
+++ b/cli/npm/resolvers/mod.rs
@@ -11,6 +11,8 @@ use deno_core::error::custom_error;
 use deno_core::error::AnyError;
 use deno_core::parking_lot::Mutex;
 use deno_core::serde_json;
+use deno_graph::npm::NpmPackageId;
+use deno_graph::npm::NpmPackageReq;
 use deno_runtime::deno_node::NodePermissions;
 use deno_runtime::deno_node::NodeResolutionMode;
 use deno_runtime::deno_node::PathClean;
@@ -30,8 +32,6 @@ use crate::util::fs::canonicalize_path_maybe_not_exists;
 use self::common::InnerNpmPackageResolver;
 use self::local::LocalNpmPackageResolver;
 use super::NpmCache;
-use super::NpmPackageId;
-use super::NpmPackageReq;
 use super::NpmResolutionSnapshot;
 use super::RealNpmRegistryApi;
 
diff --git a/cli/npm/tarball.rs b/cli/npm/tarball.rs
index 3abf4f12f..302c6308a 100644
--- a/cli/npm/tarball.rs
+++ b/cli/npm/tarball.rs
@@ -7,13 +7,13 @@ use std::path::PathBuf;
 
 use deno_core::anyhow::bail;
 use deno_core::error::AnyError;
+use deno_graph::semver::Version;
 use flate2::read::GzDecoder;
 use tar::Archive;
 use tar::EntryType;
 
 use super::cache::with_folder_sync_lock;
 use super::registry::NpmPackageVersionDistInfo;
-use crate::semver::Version;
 
 pub fn verify_and_extract_tarball(
   package: (&str, &Version),