pcp-server-ruby-sdk 0.0.6

data/node_modules/import-meta-resolve/lib/resolve.js

@@ -0,0 +1,1297 @@
+// Manually “tree shaken” from:
+// <https://github.com/nodejs/node/blob/81a9a97/lib/internal/modules/esm/resolve.js>
+// Last checked on: Apr 29, 2023.
+
+/**
+ * @typedef {import('node:fs').Stats} Stats
+ * @typedef {import('./errors.js').ErrnoException} ErrnoException
+ * @typedef {import('./package-json-reader.js').PackageConfig} PackageConfig
+ */
+
+import assert from 'node:assert'
+import {statSync, realpathSync} from 'node:fs'
+import process from 'node:process'
+import {URL, fileURLToPath, pathToFileURL} from 'node:url'
+import path from 'node:path'
+import {builtinModules} from 'node:module'
+import {defaultGetFormatWithoutErrors} from './get-format.js'
+import {codes} from './errors.js'
+import {getPackageScopeConfig, read} from './package-json-reader.js'
+import {getConditionsSet} from './utils.js'
+
+const RegExpPrototypeSymbolReplace = RegExp.prototype[Symbol.replace]
+
+const {
+  ERR_NETWORK_IMPORT_DISALLOWED,
+  ERR_INVALID_MODULE_SPECIFIER,
+  ERR_INVALID_PACKAGE_CONFIG,
+  ERR_INVALID_PACKAGE_TARGET,
+  ERR_MODULE_NOT_FOUND,
+  ERR_PACKAGE_IMPORT_NOT_DEFINED,
+  ERR_PACKAGE_PATH_NOT_EXPORTED,
+  ERR_UNSUPPORTED_DIR_IMPORT,
+  ERR_UNSUPPORTED_RESOLVE_REQUEST
+} = codes
+
+const own = {}.hasOwnProperty
+
+const invalidSegmentRegEx =
+  /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))?(\\|\/|$)/i
+const deprecatedInvalidSegmentRegEx =
+  /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))(\\|\/|$)/i
+const invalidPackageNameRegEx = /^\.|%|\\/
+const patternRegEx = /\*/g
+const encodedSeparatorRegEx = /%2f|%5c/i
+/** @type {Set<string>} */
+const emittedPackageWarnings = new Set()
+
+const doubleSlashRegEx = /[/\\]{2}/
+
+/**
+ *
+ * @param {string} target
+ * @param {string} request
+ * @param {string} match
+ * @param {URL} packageJsonUrl
+ * @param {boolean} internal
+ * @param {URL} base
+ * @param {boolean} isTarget
+ */
+function emitInvalidSegmentDeprecation(
+  target,
+  request,
+  match,
+  packageJsonUrl,
+  internal,
+  base,
+  isTarget
+) {
+  // @ts-expect-error: apparently it does exist, TS.
+  if (process.noDeprecation) {
+    return
+  }
+
+  const pjsonPath = fileURLToPath(packageJsonUrl)
+  const double = doubleSlashRegEx.exec(isTarget ? target : request) !== null
+  process.emitWarning(
+    `Use of deprecated ${
+      double ? 'double slash' : 'leading or trailing slash matching'
+    } resolving "${target}" for module ` +
+      `request "${request}" ${
+        request === match ? '' : `matched to "${match}" `
+      }in the "${
+        internal ? 'imports' : 'exports'
+      }" field module resolution of the package at ${pjsonPath}${
+        base ? ` imported from ${fileURLToPath(base)}` : ''
+      }.`,
+    'DeprecationWarning',
+    'DEP0166'
+  )
+}
+
+/**
+ * @param {URL} url
+ * @param {URL} packageJsonUrl
+ * @param {URL} base
+ * @param {string} [main]
+ * @returns {void}
+ */
+function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
+  // @ts-expect-error: apparently it does exist, TS.
+  if (process.noDeprecation) {
+    return
+  }
+
+  const format = defaultGetFormatWithoutErrors(url, {parentURL: base.href})
+  if (format !== 'module') return
+  const urlPath = fileURLToPath(url.href)
+  const packagePath = fileURLToPath(new URL('.', packageJsonUrl))
+  const basePath = fileURLToPath(base)
+  if (!main) {
+    process.emitWarning(
+      `No "main" or "exports" field defined in the package.json for ${packagePath} resolving the main entry point "${urlPath.slice(
+        packagePath.length
+      )}", imported from ${basePath}.\nDefault "index" lookups for the main are deprecated for ES modules.`,
+      'DeprecationWarning',
+      'DEP0151'
+    )
+  } else if (path.resolve(packagePath, main) !== urlPath) {
+    process.emitWarning(
+      `Package ${packagePath} has a "main" field set to "${main}", ` +
+        `excluding the full filename and extension to the resolved file at "${urlPath.slice(
+          packagePath.length
+        )}", imported from ${basePath}.\n Automatic extension resolution of the "main" field is ` +
+        'deprecated for ES modules.',
+      'DeprecationWarning',
+      'DEP0151'
+    )
+  }
+}
+
+/**
+ * @param {string} path
+ * @returns {Stats | undefined}
+ */
+function tryStatSync(path) {
+  // Note: from Node 15 onwards we can use `throwIfNoEntry: false` instead.
+  try {
+    return statSync(path)
+  } catch {
+    // Note: in Node code this returns `new Stats`,
+    // but in Node 22 that’s marked as a deprecated internal API.
+    // Which, well, we kinda are, but still to prevent that warning,
+    // just yield `undefined`.
+  }
+}
+
+/**
+ * Legacy CommonJS main resolution:
+ * 1. let M = pkg_url + (json main field)
+ * 2. TRY(M, M.js, M.json, M.node)
+ * 3. TRY(M/index.js, M/index.json, M/index.node)
+ * 4. TRY(pkg_url/index.js, pkg_url/index.json, pkg_url/index.node)
+ * 5. NOT_FOUND
+ *
+ * @param {URL} url
+ * @returns {boolean}
+ */
+function fileExists(url) {
+  const stats = statSync(url, {throwIfNoEntry: false})
+  const isFile = stats ? stats.isFile() : undefined
+  return isFile === null || isFile === undefined ? false : isFile
+}
+
+/**
+ * @param {URL} packageJsonUrl
+ * @param {PackageConfig} packageConfig
+ * @param {URL} base
+ * @returns {URL}
+ */
+function legacyMainResolve(packageJsonUrl, packageConfig, base) {
+  /** @type {URL | undefined} */
+  let guess
+  if (packageConfig.main !== undefined) {
+    guess = new URL(packageConfig.main, packageJsonUrl)
+    // Note: fs check redundances will be handled by Descriptor cache here.
+    if (fileExists(guess)) return guess
+
+    const tries = [
+      `./${packageConfig.main}.js`,
+      `./${packageConfig.main}.json`,
+      `./${packageConfig.main}.node`,
+      `./${packageConfig.main}/index.js`,
+      `./${packageConfig.main}/index.json`,
+      `./${packageConfig.main}/index.node`
+    ]
+    let i = -1
+
+    while (++i < tries.length) {
+      guess = new URL(tries[i], packageJsonUrl)
+      if (fileExists(guess)) break
+      guess = undefined
+    }
+
+    if (guess) {
+      emitLegacyIndexDeprecation(
+        guess,
+        packageJsonUrl,
+        base,
+        packageConfig.main
+      )
+      return guess
+    }
+    // Fallthrough.
+  }
+
+  const tries = ['./index.js', './index.json', './index.node']
+  let i = -1
+
+  while (++i < tries.length) {
+    guess = new URL(tries[i], packageJsonUrl)
+    if (fileExists(guess)) break
+    guess = undefined
+  }
+
+  if (guess) {
+    emitLegacyIndexDeprecation(guess, packageJsonUrl, base, packageConfig.main)
+    return guess
+  }
+
+  // Not found.
+  throw new ERR_MODULE_NOT_FOUND(
+    fileURLToPath(new URL('.', packageJsonUrl)),
+    fileURLToPath(base)
+  )
+}
+
+/**
+ * @param {URL} resolved
+ * @param {URL} base
+ * @param {boolean} [preserveSymlinks]
+ * @returns {URL}
+ */
+function finalizeResolution(resolved, base, preserveSymlinks) {
+  if (encodedSeparatorRegEx.exec(resolved.pathname) !== null) {
+    throw new ERR_INVALID_MODULE_SPECIFIER(
+      resolved.pathname,
+      'must not include encoded "/" or "\\" characters',
+      fileURLToPath(base)
+    )
+  }
+
+  /** @type {string} */
+  let filePath
+
+  try {
+    filePath = fileURLToPath(resolved)
+  } catch (error) {
+    const cause = /** @type {ErrnoException} */ (error)
+    Object.defineProperty(cause, 'input', {value: String(resolved)})
+    Object.defineProperty(cause, 'module', {value: String(base)})
+    throw cause
+  }
+
+  const stats = tryStatSync(
+    filePath.endsWith('/') ? filePath.slice(-1) : filePath
+  )
+
+  if (stats && stats.isDirectory()) {
+    const error = new ERR_UNSUPPORTED_DIR_IMPORT(filePath, fileURLToPath(base))
+    // @ts-expect-error Add this for `import.meta.resolve`.
+    error.url = String(resolved)
+    throw error
+  }
+
+  if (!stats || !stats.isFile()) {
+    const error = new ERR_MODULE_NOT_FOUND(
+      filePath || resolved.pathname,
+      base && fileURLToPath(base),
+      true
+    )
+    // @ts-expect-error Add this for `import.meta.resolve`.
+    error.url = String(resolved)
+    throw error
+  }
+
+  if (!preserveSymlinks) {
+    const real = realpathSync(filePath)
+    const {search, hash} = resolved
+    resolved = pathToFileURL(real + (filePath.endsWith(path.sep) ? '/' : ''))
+    resolved.search = search
+    resolved.hash = hash
+  }
+
+  return resolved
+}
+
+/**
+ * @param {string} specifier
+ * @param {URL | undefined} packageJsonUrl
+ * @param {URL} base
+ * @returns {Error}
+ */
+function importNotDefined(specifier, packageJsonUrl, base) {
+  return new ERR_PACKAGE_IMPORT_NOT_DEFINED(
+    specifier,
+    packageJsonUrl && fileURLToPath(new URL('.', packageJsonUrl)),
+    fileURLToPath(base)
+  )
+}
+
+/**
+ * @param {string} subpath
+ * @param {URL} packageJsonUrl
+ * @param {URL} base
+ * @returns {Error}
+ */
+function exportsNotFound(subpath, packageJsonUrl, base) {
+  return new ERR_PACKAGE_PATH_NOT_EXPORTED(
+    fileURLToPath(new URL('.', packageJsonUrl)),
+    subpath,
+    base && fileURLToPath(base)
+  )
+}
+
+/**
+ * @param {string} request
+ * @param {string} match
+ * @param {URL} packageJsonUrl
+ * @param {boolean} internal
+ * @param {URL} [base]
+ * @returns {never}
+ */
+function throwInvalidSubpath(request, match, packageJsonUrl, internal, base) {
+  const reason = `request is not a valid match in pattern "${match}" for the "${
+    internal ? 'imports' : 'exports'
+  }" resolution of ${fileURLToPath(packageJsonUrl)}`
+  throw new ERR_INVALID_MODULE_SPECIFIER(
+    request,
+    reason,
+    base && fileURLToPath(base)
+  )
+}
+
+/**
+ * @param {string} subpath
+ * @param {unknown} target
+ * @param {URL} packageJsonUrl
+ * @param {boolean} internal
+ * @param {URL} [base]
+ * @returns {Error}
+ */
+function invalidPackageTarget(subpath, target, packageJsonUrl, internal, base) {
+  target =
+    typeof target === 'object' && target !== null
+      ? JSON.stringify(target, null, '')
+      : `${target}`
+
+  return new ERR_INVALID_PACKAGE_TARGET(
+    fileURLToPath(new URL('.', packageJsonUrl)),
+    subpath,
+    target,
+    internal,
+    base && fileURLToPath(base)
+  )
+}
+
+/**
+ * @param {string} target
+ * @param {string} subpath
+ * @param {string} match
+ * @param {URL} packageJsonUrl
+ * @param {URL} base
+ * @param {boolean} pattern
+ * @param {boolean} internal
+ * @param {boolean} isPathMap
+ * @param {Set<string> | undefined} conditions
+ * @returns {URL}
+ */
+function resolvePackageTargetString(
+  target,
+  subpath,
+  match,
+  packageJsonUrl,
+  base,
+  pattern,
+  internal,
+  isPathMap,
+  conditions
+) {
+  if (subpath !== '' && !pattern && target[target.length - 1] !== '/')
+    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base)
+
+  if (!target.startsWith('./')) {
+    if (internal && !target.startsWith('../') && !target.startsWith('/')) {
+      let isURL = false
+
+      try {
+        new URL(target)
+        isURL = true
+      } catch {
+        // Continue regardless of error.
+      }
+
+      if (!isURL) {
+        const exportTarget = pattern
+          ? RegExpPrototypeSymbolReplace.call(
+              patternRegEx,
+              target,
+              () => subpath
+            )
+          : target + subpath
+
+        return packageResolve(exportTarget, packageJsonUrl, conditions)
+      }
+    }
+
+    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base)
+  }
+
+  if (invalidSegmentRegEx.exec(target.slice(2)) !== null) {
+    if (deprecatedInvalidSegmentRegEx.exec(target.slice(2)) === null) {
+      if (!isPathMap) {
+        const request = pattern
+          ? match.replace('*', () => subpath)
+          : match + subpath
+        const resolvedTarget = pattern
+          ? RegExpPrototypeSymbolReplace.call(
+              patternRegEx,
+              target,
+              () => subpath
+            )
+          : target
+        emitInvalidSegmentDeprecation(
+          resolvedTarget,
+          request,
+          match,
+          packageJsonUrl,
+          internal,
+          base,
+          true
+        )
+      }
+    } else {
+      throw invalidPackageTarget(match, target, packageJsonUrl, internal, base)
+    }
+  }
+
+  const resolved = new URL(target, packageJsonUrl)
+  const resolvedPath = resolved.pathname
+  const packagePath = new URL('.', packageJsonUrl).pathname
+
+  if (!resolvedPath.startsWith(packagePath))
+    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base)
+
+  if (subpath === '') return resolved
+
+  if (invalidSegmentRegEx.exec(subpath) !== null) {
+    const request = pattern
+      ? match.replace('*', () => subpath)
+      : match + subpath
+    if (deprecatedInvalidSegmentRegEx.exec(subpath) === null) {
+      if (!isPathMap) {
+        const resolvedTarget = pattern
+          ? RegExpPrototypeSymbolReplace.call(
+              patternRegEx,
+              target,
+              () => subpath
+            )
+          : target
+        emitInvalidSegmentDeprecation(
+          resolvedTarget,
+          request,
+          match,
+          packageJsonUrl,
+          internal,
+          base,
+          false
+        )
+      }
+    } else {
+      throwInvalidSubpath(request, match, packageJsonUrl, internal, base)
+    }
+  }
+
+  if (pattern) {
+    return new URL(
+      RegExpPrototypeSymbolReplace.call(
+        patternRegEx,
+        resolved.href,
+        () => subpath
+      )
+    )
+  }
+
+  return new URL(subpath, resolved)
+}
+
+/**
+ * @param {string} key
+ * @returns {boolean}
+ */
+function isArrayIndex(key) {
+  const keyNumber = Number(key)
+  if (`${keyNumber}` !== key) return false
+  return keyNumber >= 0 && keyNumber < 0xff_ff_ff_ff
+}
+
+/**
+ * @param {URL} packageJsonUrl
+ * @param {unknown} target
+ * @param {string} subpath
+ * @param {string} packageSubpath
+ * @param {URL} base
+ * @param {boolean} pattern
+ * @param {boolean} internal
+ * @param {boolean} isPathMap
+ * @param {Set<string> | undefined} conditions
+ * @returns {URL | null}
+ */
+function resolvePackageTarget(
+  packageJsonUrl,
+  target,
+  subpath,
+  packageSubpath,
+  base,
+  pattern,
+  internal,
+  isPathMap,
+  conditions
+) {
+  if (typeof target === 'string') {
+    return resolvePackageTargetString(
+      target,
+      subpath,
+      packageSubpath,
+      packageJsonUrl,
+      base,
+      pattern,
+      internal,
+      isPathMap,
+      conditions
+    )
+  }
+
+  if (Array.isArray(target)) {
+    /** @type {Array<unknown>} */
+    const targetList = target
+    if (targetList.length === 0) return null
+
+    /** @type {ErrnoException | null | undefined} */
+    let lastException
+    let i = -1
+
+    while (++i < targetList.length) {
+      const targetItem = targetList[i]
+      /** @type {URL | null} */
+      let resolveResult
+      try {
+        resolveResult = resolvePackageTarget(
+          packageJsonUrl,
+          targetItem,
+          subpath,
+          packageSubpath,
+          base,
+          pattern,
+          internal,
+          isPathMap,
+          conditions
+        )
+      } catch (error) {
+        const exception = /** @type {ErrnoException} */ (error)
+        lastException = exception
+        if (exception.code === 'ERR_INVALID_PACKAGE_TARGET') continue
+        throw error
+      }
+
+      if (resolveResult === undefined) continue
+
+      if (resolveResult === null) {
+        lastException = null
+        continue
+      }
+
+      return resolveResult
+    }
+
+    if (lastException === undefined || lastException === null) {
+      return null
+    }
+
+    throw lastException
+  }
+
+  if (typeof target === 'object' && target !== null) {
+    const keys = Object.getOwnPropertyNames(target)
+    let i = -1
+
+    while (++i < keys.length) {
+      const key = keys[i]
+      if (isArrayIndex(key)) {
+        throw new ERR_INVALID_PACKAGE_CONFIG(
+          fileURLToPath(packageJsonUrl),
+          base,
+          '"exports" cannot contain numeric property keys.'
+        )
+      }
+    }
+
+    i = -1
+
+    while (++i < keys.length) {
+      const key = keys[i]
+      if (key === 'default' || (conditions && conditions.has(key))) {
+        // @ts-expect-error: indexable.
+        const conditionalTarget = /** @type {unknown} */ (target[key])
+        const resolveResult = resolvePackageTarget(
+          packageJsonUrl,
+          conditionalTarget,
+          subpath,
+          packageSubpath,
+          base,
+          pattern,
+          internal,
+          isPathMap,
+          conditions
+        )
+        if (resolveResult === undefined) continue
+        return resolveResult
+      }
+    }
+
+    return null
+  }
+
+  if (target === null) {
+    return null
+  }
+
+  throw invalidPackageTarget(
+    packageSubpath,
+    target,
+    packageJsonUrl,
+    internal,
+    base
+  )
+}
+
+/**
+ * @param {unknown} exports
+ * @param {URL} packageJsonUrl
+ * @param {URL} base
+ * @returns {boolean}
+ */
+function isConditionalExportsMainSugar(exports, packageJsonUrl, base) {
+  if (typeof exports === 'string' || Array.isArray(exports)) return true
+  if (typeof exports !== 'object' || exports === null) return false
+
+  const keys = Object.getOwnPropertyNames(exports)
+  let isConditionalSugar = false
+  let i = 0
+  let keyIndex = -1
+  while (++keyIndex < keys.length) {
+    const key = keys[keyIndex]
+    const currentIsConditionalSugar = key === '' || key[0] !== '.'
+    if (i++ === 0) {
+      isConditionalSugar = currentIsConditionalSugar
+    } else if (isConditionalSugar !== currentIsConditionalSugar) {
+      throw new ERR_INVALID_PACKAGE_CONFIG(
+        fileURLToPath(packageJsonUrl),
+        base,
+        '"exports" cannot contain some keys starting with \'.\' and some not.' +
+          ' The exports object must either be an object of package subpath keys' +
+          ' or an object of main entry condition name keys only.'
+      )
+    }
+  }
+
+  return isConditionalSugar
+}
+
+/**
+ * @param {string} match
+ * @param {URL} pjsonUrl
+ * @param {URL} base
+ */
+function emitTrailingSlashPatternDeprecation(match, pjsonUrl, base) {
+  // @ts-expect-error: apparently it does exist, TS.
+  if (process.noDeprecation) {
+    return
+  }
+
+  const pjsonPath = fileURLToPath(pjsonUrl)
+  if (emittedPackageWarnings.has(pjsonPath + '|' + match)) return
+  emittedPackageWarnings.add(pjsonPath + '|' + match)
+  process.emitWarning(
+    `Use of deprecated trailing slash pattern mapping "${match}" in the ` +
+      `"exports" field module resolution of the package at ${pjsonPath}${
+        base ? ` imported from ${fileURLToPath(base)}` : ''
+      }. Mapping specifiers ending in "/" is no longer supported.`,
+    'DeprecationWarning',
+    'DEP0155'
+  )
+}
+
+/**
+ * @param {URL} packageJsonUrl
+ * @param {string} packageSubpath
+ * @param {Record<string, unknown>} packageConfig
+ * @param {URL} base
+ * @param {Set<string> | undefined} conditions
+ * @returns {URL}
+ */
+function packageExportsResolve(
+  packageJsonUrl,
+  packageSubpath,
+  packageConfig,
+  base,
+  conditions
+) {
+  let exports = packageConfig.exports
+
+  if (isConditionalExportsMainSugar(exports, packageJsonUrl, base)) {
+    exports = {'.': exports}
+  }
+
+  if (
+    own.call(exports, packageSubpath) &&
+    !packageSubpath.includes('*') &&
+    !packageSubpath.endsWith('/')
+  ) {
+    // @ts-expect-error: indexable.
+    const target = exports[packageSubpath]
+    const resolveResult = resolvePackageTarget(
+      packageJsonUrl,
+      target,
+      '',
+      packageSubpath,
+      base,
+      false,
+      false,
+      false,
+      conditions
+    )
+    if (resolveResult === null || resolveResult === undefined) {
+      throw exportsNotFound(packageSubpath, packageJsonUrl, base)
+    }
+
+    return resolveResult
+  }
+
+  let bestMatch = ''
+  let bestMatchSubpath = ''
+  const keys = Object.getOwnPropertyNames(exports)
+  let i = -1
+
+  while (++i < keys.length) {
+    const key = keys[i]
+    const patternIndex = key.indexOf('*')
+
+    if (
+      patternIndex !== -1 &&
+      packageSubpath.startsWith(key.slice(0, patternIndex))
+    ) {
+      // When this reaches EOL, this can throw at the top of the whole function:
+      //
+      // if (StringPrototypeEndsWith(packageSubpath, '/'))
+      //   throwInvalidSubpath(packageSubpath)
+      //
+      // To match "imports" and the spec.
+      if (packageSubpath.endsWith('/')) {
+        emitTrailingSlashPatternDeprecation(
+          packageSubpath,
+          packageJsonUrl,
+          base
+        )
+      }
+
+      const patternTrailer = key.slice(patternIndex + 1)
+
+      if (
+        packageSubpath.length >= key.length &&
+        packageSubpath.endsWith(patternTrailer) &&
+        patternKeyCompare(bestMatch, key) === 1 &&
+        key.lastIndexOf('*') === patternIndex
+      ) {
+        bestMatch = key
+        bestMatchSubpath = packageSubpath.slice(
+          patternIndex,
+          packageSubpath.length - patternTrailer.length
+        )
+      }
+    }
+  }
+
+  if (bestMatch) {
+    // @ts-expect-error: indexable.
+    const target = /** @type {unknown} */ (exports[bestMatch])
+    const resolveResult = resolvePackageTarget(
+      packageJsonUrl,
+      target,
+      bestMatchSubpath,
+      bestMatch,
+      base,
+      true,
+      false,
+      packageSubpath.endsWith('/'),
+      conditions
+    )
+
+    if (resolveResult === null || resolveResult === undefined) {
+      throw exportsNotFound(packageSubpath, packageJsonUrl, base)
+    }
+
+    return resolveResult
+  }
+
+  throw exportsNotFound(packageSubpath, packageJsonUrl, base)
+}
+
+/**
+ * @param {string} a
+ * @param {string} b
+ */
+function patternKeyCompare(a, b) {
+  const aPatternIndex = a.indexOf('*')
+  const bPatternIndex = b.indexOf('*')
+  const baseLengthA = aPatternIndex === -1 ? a.length : aPatternIndex + 1
+  const baseLengthB = bPatternIndex === -1 ? b.length : bPatternIndex + 1
+  if (baseLengthA > baseLengthB) return -1
+  if (baseLengthB > baseLengthA) return 1
+  if (aPatternIndex === -1) return 1
+  if (bPatternIndex === -1) return -1
+  if (a.length > b.length) return -1
+  if (b.length > a.length) return 1
+  return 0
+}
+
+/**
+ * @param {string} name
+ * @param {URL} base
+ * @param {Set<string>} [conditions]
+ * @returns {URL}
+ */
+function packageImportsResolve(name, base, conditions) {
+  if (name === '#' || name.startsWith('#/') || name.endsWith('/')) {
+    const reason = 'is not a valid internal imports specifier name'
+    throw new ERR_INVALID_MODULE_SPECIFIER(name, reason, fileURLToPath(base))
+  }
+
+  /** @type {URL | undefined} */
+  let packageJsonUrl
+
+  const packageConfig = getPackageScopeConfig(base)
+
+  if (packageConfig.exists) {
+    packageJsonUrl = pathToFileURL(packageConfig.pjsonPath)
+    const imports = packageConfig.imports
+    if (imports) {
+      if (own.call(imports, name) && !name.includes('*')) {
+        const resolveResult = resolvePackageTarget(
+          packageJsonUrl,
+          imports[name],
+          '',
+          name,
+          base,
+          false,
+          true,
+          false,
+          conditions
+        )
+        if (resolveResult !== null && resolveResult !== undefined) {
+          return resolveResult
+        }
+      } else {
+        let bestMatch = ''
+        let bestMatchSubpath = ''
+        const keys = Object.getOwnPropertyNames(imports)
+        let i = -1
+
+        while (++i < keys.length) {
+          const key = keys[i]
+          const patternIndex = key.indexOf('*')
+
+          if (patternIndex !== -1 && name.startsWith(key.slice(0, -1))) {
+            const patternTrailer = key.slice(patternIndex + 1)
+            if (
+              name.length >= key.length &&
+              name.endsWith(patternTrailer) &&
+              patternKeyCompare(bestMatch, key) === 1 &&
+              key.lastIndexOf('*') === patternIndex
+            ) {
+              bestMatch = key
+              bestMatchSubpath = name.slice(
+                patternIndex,
+                name.length - patternTrailer.length
+              )
+            }
+          }
+        }
+
+        if (bestMatch) {
+          const target = imports[bestMatch]
+          const resolveResult = resolvePackageTarget(
+            packageJsonUrl,
+            target,
+            bestMatchSubpath,
+            bestMatch,
+            base,
+            true,
+            true,
+            false,
+            conditions
+          )
+
+          if (resolveResult !== null && resolveResult !== undefined) {
+            return resolveResult
+          }
+        }
+      }
+    }
+  }
+
+  throw importNotDefined(name, packageJsonUrl, base)
+}
+
+/**
+ * @param {string} specifier
+ * @param {URL} base
+ */
+function parsePackageName(specifier, base) {
+  let separatorIndex = specifier.indexOf('/')
+  let validPackageName = true
+  let isScoped = false
+  if (specifier[0] === '@') {
+    isScoped = true
+    if (separatorIndex === -1 || specifier.length === 0) {
+      validPackageName = false
+    } else {
+      separatorIndex = specifier.indexOf('/', separatorIndex + 1)
+    }
+  }
+
+  const packageName =
+    separatorIndex === -1 ? specifier : specifier.slice(0, separatorIndex)
+
+  // Package name cannot have leading . and cannot have percent-encoding or
+  // \\ separators.
+  if (invalidPackageNameRegEx.exec(packageName) !== null) {
+    validPackageName = false
+  }
+
+  if (!validPackageName) {
+    throw new ERR_INVALID_MODULE_SPECIFIER(
+      specifier,
+      'is not a valid package name',
+      fileURLToPath(base)
+    )
+  }
+
+  const packageSubpath =
+    '.' + (separatorIndex === -1 ? '' : specifier.slice(separatorIndex))
+
+  return {packageName, packageSubpath, isScoped}
+}
+
+/**
+ * @param {string} specifier
+ * @param {URL} base
+ * @param {Set<string> | undefined} conditions
+ * @returns {URL}
+ */
+function packageResolve(specifier, base, conditions) {
+  if (builtinModules.includes(specifier)) {
+    return new URL('node:' + specifier)
+  }
+
+  const {packageName, packageSubpath, isScoped} = parsePackageName(
+    specifier,
+    base
+  )
+
+  // ResolveSelf
+  const packageConfig = getPackageScopeConfig(base)
+
+  // Can’t test.
+  /* c8 ignore next 16 */
+  if (packageConfig.exists) {
+    const packageJsonUrl = pathToFileURL(packageConfig.pjsonPath)
+    if (
+      packageConfig.name === packageName &&
+      packageConfig.exports !== undefined &&
+      packageConfig.exports !== null
+    ) {
+      return packageExportsResolve(
+        packageJsonUrl,
+        packageSubpath,
+        packageConfig,
+        base,
+        conditions
+      )
+    }
+  }
+
+  let packageJsonUrl = new URL(
+    './node_modules/' + packageName + '/package.json',
+    base
+  )
+  let packageJsonPath = fileURLToPath(packageJsonUrl)
+  /** @type {string} */
+  let lastPath
+  do {
+    const stat = tryStatSync(packageJsonPath.slice(0, -13))
+    if (!stat || !stat.isDirectory()) {
+      lastPath = packageJsonPath
+      packageJsonUrl = new URL(
+        (isScoped ? '../../../../node_modules/' : '../../../node_modules/') +
+          packageName +
+          '/package.json',
+        packageJsonUrl
+      )
+      packageJsonPath = fileURLToPath(packageJsonUrl)
+      continue
+    }
+
+    // Package match.
+    const packageConfig = read(packageJsonPath, {base, specifier})
+    if (packageConfig.exports !== undefined && packageConfig.exports !== null) {
+      return packageExportsResolve(
+        packageJsonUrl,
+        packageSubpath,
+        packageConfig,
+        base,
+        conditions
+      )
+    }
+
+    if (packageSubpath === '.') {
+      return legacyMainResolve(packageJsonUrl, packageConfig, base)
+    }
+
+    return new URL(packageSubpath, packageJsonUrl)
+    // Cross-platform root check.
+  } while (packageJsonPath.length !== lastPath.length)
+
+  throw new ERR_MODULE_NOT_FOUND(packageName, fileURLToPath(base), false)
+}
+
+/**
+ * @param {string} specifier
+ * @returns {boolean}
+ */
+function isRelativeSpecifier(specifier) {
+  if (specifier[0] === '.') {
+    if (specifier.length === 1 || specifier[1] === '/') return true
+    if (
+      specifier[1] === '.' &&
+      (specifier.length === 2 || specifier[2] === '/')
+    ) {
+      return true
+    }
+  }
+
+  return false
+}
+
+/**
+ * @param {string} specifier
+ * @returns {boolean}
+ */
+function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
+  if (specifier === '') return false
+  if (specifier[0] === '/') return true
+  return isRelativeSpecifier(specifier)
+}
+
+/**
+ * The “Resolver Algorithm Specification” as detailed in the Node docs (which is
+ * sync and slightly lower-level than `resolve`).
+ *
+ * @param {string} specifier
+ *   `/example.js`, `./example.js`, `../example.js`, `some-package`, `fs`, etc.
+ * @param {URL} base
+ *   Full URL (to a file) that `specifier` is resolved relative from.
+ * @param {Set<string>} [conditions]
+ *   Conditions.
+ * @param {boolean} [preserveSymlinks]
+ *   Keep symlinks instead of resolving them.
+ * @returns {URL}
+ *   A URL object to the found thing.
+ */
+export function moduleResolve(specifier, base, conditions, preserveSymlinks) {
+  // Note: The Node code supports `base` as a string (in this internal API) too,
+  // we don’t.
+  const protocol = base.protocol
+  const isData = protocol === 'data:'
+  const isRemote = isData || protocol === 'http:' || protocol === 'https:'
+  // Order swapped from spec for minor perf gain.
+  // Ok since relative URLs cannot parse as URLs.
+  /** @type {URL | undefined} */
+  let resolved
+
+  if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
+    try {
+      resolved = new URL(specifier, base)
+    } catch (error_) {
+      const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base)
+      error.cause = error_
+      throw error
+    }
+  } else if (protocol === 'file:' && specifier[0] === '#') {
+    resolved = packageImportsResolve(specifier, base, conditions)
+  } else {
+    try {
+      resolved = new URL(specifier)
+    } catch (error_) {
+      // Note: actual code uses `canBeRequiredWithoutScheme`.
+      if (isRemote && !builtinModules.includes(specifier)) {
+        const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base)
+        error.cause = error_
+        throw error
+      }
+
+      resolved = packageResolve(specifier, base, conditions)
+    }
+  }
+
+  assert(resolved !== undefined, 'expected to be defined')
+
+  if (resolved.protocol !== 'file:') {
+    return resolved
+  }
+
+  return finalizeResolution(resolved, base, preserveSymlinks)
+}
+
+/**
+ * @param {string} specifier
+ * @param {URL | undefined} parsed
+ * @param {URL | undefined} parsedParentURL
+ */
+function checkIfDisallowedImport(specifier, parsed, parsedParentURL) {
+  if (parsedParentURL) {
+    // Avoid accessing the `protocol` property due to the lazy getters.
+    const parentProtocol = parsedParentURL.protocol
+
+    if (parentProtocol === 'http:' || parentProtocol === 'https:') {
+      if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
+        // Avoid accessing the `protocol` property due to the lazy getters.
+        const parsedProtocol = parsed?.protocol
+
+        // `data:` and `blob:` disallowed due to allowing file: access via
+        // indirection
+        if (
+          parsedProtocol &&
+          parsedProtocol !== 'https:' &&
+          parsedProtocol !== 'http:'
+        ) {
+          throw new ERR_NETWORK_IMPORT_DISALLOWED(
+            specifier,
+            parsedParentURL,
+            'remote imports cannot import from a local location.'
+          )
+        }
+
+        return {url: parsed?.href || ''}
+      }
+
+      if (builtinModules.includes(specifier)) {
+        throw new ERR_NETWORK_IMPORT_DISALLOWED(
+          specifier,
+          parsedParentURL,
+          'remote imports cannot import from a local location.'
+        )
+      }
+
+      throw new ERR_NETWORK_IMPORT_DISALLOWED(
+        specifier,
+        parsedParentURL,
+        'only relative and absolute specifiers are supported.'
+      )
+    }
+  }
+}
+
+// Note: this is from:
+// <https://github.com/nodejs/node/blob/3e74590/lib/internal/url.js#L687>
+/**
+ * Checks if a value has the shape of a WHATWG URL object.
+ *
+ * Using a symbol or instanceof would not be able to recognize URL objects
+ * coming from other implementations (e.g. in Electron), so instead we are
+ * checking some well known properties for a lack of a better test.
+ *
+ * We use `href` and `protocol` as they are the only properties that are
+ * easy to retrieve and calculate due to the lazy nature of the getters.
+ *
+ * @template {unknown} Value
+ * @param {Value} self
+ * @returns {Value is URL}
+ */
+function isURL(self) {
+  return Boolean(
+    self &&
+      typeof self === 'object' &&
+      'href' in self &&
+      typeof self.href === 'string' &&
+      'protocol' in self &&
+      typeof self.protocol === 'string' &&
+      self.href &&
+      self.protocol
+  )
+}
+
+/**
+ * Validate user-input in `context` supplied by a custom loader.
+ *
+ * @param {unknown} parentURL
+ * @returns {asserts parentURL is URL | string | undefined}
+ */
+function throwIfInvalidParentURL(parentURL) {
+  if (parentURL === undefined) {
+    return // Main entry point, so no parent
+  }
+
+  if (typeof parentURL !== 'string' && !isURL(parentURL)) {
+    throw new codes.ERR_INVALID_ARG_TYPE(
+      'parentURL',
+      ['string', 'URL'],
+      parentURL
+    )
+  }
+}
+
+/**
+ * @param {string} specifier
+ * @param {{parentURL?: string, conditions?: Array<string>}} context
+ * @returns {{url: string, format?: string | null}}
+ */
+export function defaultResolve(specifier, context = {}) {
+  const {parentURL} = context
+  assert(parentURL !== undefined, 'expected `parentURL` to be defined')
+  throwIfInvalidParentURL(parentURL)
+
+  /** @type {URL | undefined} */
+  let parsedParentURL
+  if (parentURL) {
+    try {
+      parsedParentURL = new URL(parentURL)
+    } catch {
+      // Ignore exception
+    }
+  }
+
+  /** @type {URL | undefined} */
+  let parsed
+  /** @type {string | undefined} */
+  let protocol
+
+  try {
+    parsed = shouldBeTreatedAsRelativeOrAbsolutePath(specifier)
+      ? new URL(specifier, parsedParentURL)
+      : new URL(specifier)
+
+    // Avoid accessing the `protocol` property due to the lazy getters.
+    protocol = parsed.protocol
+
+    if (protocol === 'data:') {
+      return {url: parsed.href, format: null}
+    }
+  } catch {
+    // Ignore exception
+  }
+
+  // There are multiple deep branches that can either throw or return; instead
+  // of duplicating that deeply nested logic for the possible returns, DRY and
+  // check for a return. This seems the least gnarly.
+  const maybeReturn = checkIfDisallowedImport(
+    specifier,
+    parsed,
+    parsedParentURL
+  )
+
+  if (maybeReturn) return maybeReturn
+
+  // This must come after checkIfDisallowedImport
+  if (protocol === undefined && parsed) {
+    protocol = parsed.protocol
+  }
+
+  if (protocol === 'node:') {
+    return {url: specifier}
+  }
+
+  // This must come after checkIfDisallowedImport
+  if (parsed && parsed.protocol === 'node:') return {url: specifier}
+
+  const conditions = getConditionsSet(context.conditions)
+
+  const url = moduleResolve(specifier, new URL(parentURL), conditions, false)
+
+  return {
+    // Do NOT cast `url` to a string: that will work even when there are real
+    // problems, silencing them
+    url: url.href,
+    format: defaultGetFormatWithoutErrors(url, {parentURL})
+  }
+}