@flex-development/mlly 1.0.0-alpha.11 → 1.0.0-alpha.13

package/src/internal/validate-map.ts

@@ -0,0 +1,33 @@
+/**
+ * @file Internal - validateMap
+ * @module mlly/internal/validateMap
+ */
+
+import { ERR_INVALID_ARG_TYPE, type NodeError } from '@flex-development/errnode'
+
+/**
+ * Checks if given `value` is a {@linkcode Map}.
+ *
+ * Throws [`ERR_INVALID_ARG_TYPE`][1] if the `value` is not a {@linkcode Map}.
+ *
+ * [1]: https://nodejs.org/api/errors.html#err_invalid_arg_value
+ *
+ * @see {@linkcode ERR_INVALID_ARG_TYPE}
+ *
+ * @template K - Map key type(s)
+ * @template V - Item type(s)
+ *
+ * @param {unknown} value - Value supplied by user
+ * @param {string} name - Name of invalid argument or property
+ * @return {value is Map<K, V>} `true` if `value` is a {@linkcode Map}
+ * @throws {NodeError<TypeError>} If `value` is not a {@linkcode Map}
+ */
+function validateMap<K extends string = string, V = unknown>(
+  value: unknown,
+  name: string
+): value is Map<K, V> {
+  if (value instanceof Map) return true
+  throw new ERR_INVALID_ARG_TYPE(name, ['Map'], value)
+}
+
+export default validateMap

package/src/internal/validate-set.ts

@@ -6,10 +6,9 @@
 import { ERR_INVALID_ARG_TYPE, type NodeError } from '@flex-development/errnode'
 
 /**
- * Checks if given `value` is an instance of {@linkcode Set}.
+ * Checks if given `value` is a {@linkcode Set}.
  *
- * Throws [`ERR_INVALID_ARG_TYPE`][1] if the `value` is not a {@linkcode Set}
- * instance.
+ * Throws [`ERR_INVALID_ARG_TYPE`][1] if the `value` is not a {@linkcode Set}.
  *
  * [1]: https://nodejs.org/api/errors.html#err_invalid_arg_value
  *
@@ -19,8 +18,8 @@ import { ERR_INVALID_ARG_TYPE, type NodeError } from '@flex-development/errnode'
  *
  * @param {unknown} value - Value supplied by user
  * @param {string} name - Name of invalid argument or property
- * @return {value is Set} `true` if `value` is instance of {@linkcode Set}
- * @throws {NodeError<TypeError>} If `value` is an instance of {@linkcode Set}
+ * @return {value is Set<T>} `true` if `value` is a {@linkcode Set}
+ * @throws {NodeError<TypeError>} If `value` is not a {@linkcode Set}
  */
 function validateSet<T = unknown>(
   value: unknown,

package/src/utils/fill-modules.ts

@@ -7,7 +7,12 @@ import { SpecifierSyntaxKind } from '#src/enums'
 import type { FillModuleOptions } from '#src/interfaces'
 import regexp from '#src/internal/escape-reg-exp'
 import isFunction from '#src/internal/is-function'
-import { ERR_UNKNOWN_FILE_EXTENSION } from '@flex-development/errnode'
+import validateArraySet from '#src/internal/validate-array-set'
+import validateURLString from '#src/internal/validate-url-string'
+import {
+  ERR_UNKNOWN_FILE_EXTENSION,
+  type NodeError
+} from '@flex-development/errnode'
 import pathe from '@flex-development/pathe'
 import type { URL } from 'node:url'
 import CONDITIONS from './conditions'
@@ -33,6 +38,7 @@ import toRelativeSpecifier from './to-relative-specifier'
  * @param {string} code - Code to evaluate
  * @param {FillModuleOptions} options - Module fill options
  * @return {Promise<string>} `code` with fully specified module specifiers
+ * @throws {NodeError<TypeError>}
  */
 const fillModules = async (
   code: string,
@@ -40,6 +46,9 @@ const fillModules = async (
 ): Promise<string> => {
   const { conditions = CONDITIONS, ext, parent = import.meta.url } = options
 
+  validateArraySet(conditions, 'options.conditions')
+  validateURLString(parent, 'options.parent')
+
   // ensure specifiers have file extensions
   for (const statement of extractStatements(code)) {
     // do nothing if statement does not have specifier

package/src/utils/find-requires.ts

@@ -33,7 +33,7 @@ const findRequires = (code: string = ''): RequireStatement[] => {
    * @const {RegExp} REQUIRE_REGEX
    */
   const REQUIRE_REGEX: RegExp =
-    /(?<=^|[\s;])\b(?:(?:const\s*|let\s*|var\s*)?(?<imports>(?:[$_\p{ID_Start}][$\u200C\u200D\p{ID_Continue}]*)|(?:[\w\t\n\r "$'*,./:{}-]+?))?\s*=?\s*(?<kind>require)\((?<specifier>["']?[\S\t\n\r]+?["']?)\)(?=;?\n?))(?<!(?:\/\/|\*).*)/gu
+    /(?<=^|[\s,:;([])\b(?:(?:const\s*|let\s*|var\s*)?(?:(?<=(?:const\s*|let\s*|var\s*))(?<imports>(?:[$_\p{ID_Start}][$\u200C\u200D\p{ID_Continue}]*)|(?:[\w\t\n\r "$'*,./:{}-]+?)))?\s*=?\s*(?<kind>require)\((?<specifier>["']?[\S\t\n\r]+?["']?)\))(?<!(?:\/\/|\*).*)/gu
 
   return [...code.matchAll(REQUIRE_REGEX)].map(match => {
     const { 0: code = '', index: start = 0, groups = {} } = match

package/src/utils/find-subpath.ts

@@ -24,7 +24,8 @@ import toURL from './to-url'
  * Finds the subpath defined in `context`, a `package.json` [`exports`][1] or
  * [`imports`][2] field, that maps to the given package `target`.
  *
- * Supports extensionless targets. Returns `null` if a subpath is not found.
+ * Supports extensionless targets and targets without explicit `'/index'` usage.
+ * Returns `null` if a subpath is not found.
  *
  * [1]: https://nodejs.org/api/packages.html#exports
  * [2]: https://nodejs.org/api/packages.html#imports
@@ -181,10 +182,17 @@ const findSubpath = (
               /**
                * {@linkcode tar} without file extension.
                *
-               * @const {string} tar_no_ext
+               * @const {string} tar_ne
                */
               const tar_ne: string = pathe.changeExt(tar, '')
 
+              /**
+               * {@linkcode tar_ne} without `'/index'`.
+               *
+               * @const {string} tar_ni
+               */
+              const tar_ni: string = tar_ne.replace(/\/index$/, '')
+
               /**
                * Index of {@linkcode PATTERN_CHARACTER} in {@linkcode tar}.
                *
@@ -196,6 +204,7 @@ const findSubpath = (
                 // target is an exactish match
                 case target === tar:
                 case target === tar_ne:
+                case target === tar_ni && tar_ne.endsWith('/index'):
                 case pattern === -1 && (target === tar || target === tar_ne):
                   subpath = pkgsubpath
                   break

package/src/utils/get-format.ts

@@ -5,6 +5,9 @@
 
 import { Format } from '#src/enums'
 import type { GetFormatOptions, PackageScope } from '#src/interfaces'
+import validateBoolean from '#src/internal/validate-boolean'
+import validateMap from '#src/internal/validate-map'
+import validateObject from '#src/internal/validate-object'
 import type { ModuleId } from '#src/types'
 import {
   ERR_UNKNOWN_FILE_EXTENSION,
@@ -12,7 +15,12 @@ import {
 } from '@flex-development/errnode'
 import { isBuiltin } from '@flex-development/is-builtin'
 import pathe, { type Ext } from '@flex-development/pathe'
-import type { EmptyString, Nilable, Nullable } from '@flex-development/tutils'
+import {
+  isUndefined,
+  type EmptyString,
+  type Nilable,
+  type Nullable
+} from '@flex-development/tutils'
 import type { URL } from 'node:url'
 import EXTENSION_FORMAT_MAP from './extension-format-map'
 import lookupPackageScope from './lookup-package-scope'
@@ -22,6 +30,13 @@ import toURL from './to-url'
 /**
  * Retrieves a module format for the given module `id`.
  *
+ * ::: tip
+ * The given module `id` should be absolute (i.e. a [`file:` URL][1] or absolute
+ * specifier).
+ * :::
+ *
+ * [1]: https://nodejs.org/api/esm.html#file-urls
+ *
  * @see {@linkcode Format}
  * @see {@linkcode GetFormatOptions}
  * @see {@linkcode ModuleId}
@@ -38,21 +53,27 @@ const getFormat = async (
   options: GetFormatOptions = {}
 ): Promise<Nilable<Format>> => {
   const {
-    base,
-    experimental_json_modules = true,
-    experimental_network_imports = false,
-    experimental_wasm_modules = false,
+    experimental_json_modules: json_modules = true,
+    experimental_network_imports: network_imports = false,
+    experimental_wasm_modules: wasm_modules = false,
     extension_format_map = EXTENSION_FORMAT_MAP,
     ignore_errors = false,
-    req
+    req = {}
   } = options
 
+  validateBoolean(json_modules, 'options.experimental_json_modules')
+  validateBoolean(network_imports, 'options.experimental_network_imports')
+  validateBoolean(wasm_modules, 'options.experimental_wasm_modules')
+  validateBoolean(ignore_errors, 'options.ignore_errors')
+  validateMap(extension_format_map, 'options.extension_format_map')
+  !isUndefined(req) && validateObject(req, 'options.req')
+
   /**
    * Module {@linkcode id} as {@linkcode URL}.
    *
    * @const {URL} url
    */
-  const url: URL = toURL(id, base)
+  const url: URL = toURL(id)
 
   /**
    * Extracts a [MIME type][1] from a {@linkcode URL} href, {@linkcode URL}
@@ -94,10 +115,10 @@ const getFormat = async (
           format = Format.MODULE
           break
         case 'application/json':
-          format = experimental_json_modules ? Format.JSON : null
+          format = json_modules ? Format.JSON : null
           break
         case 'application/wasm':
-          format = experimental_wasm_modules ? Format.WASM : null
+          format = wasm_modules ? Format.WASM : null
           break
         default:
           break
@@ -149,8 +170,8 @@ const getFormat = async (
           format = extension_format_map.get(ext)!
 
           switch (true) {
-            case format === Format.JSON && !experimental_json_modules:
-            case format === Format.WASM && !experimental_wasm_modules:
+            case format === Format.JSON && !json_modules:
+            case format === Format.WASM && !wasm_modules:
               format = ignore_errors ? undefined : null
               break
             default:
@@ -200,7 +221,7 @@ const getFormat = async (
       break
     case 'http:':
     case 'https:':
-      if (experimental_network_imports) {
+      if (network_imports) {
         const { default: fetch } = await import('node-fetch')
         const { headers } = await fetch(url.href, req)
         format = mimeToFormat(headers.get('content-type'), true)

package/src/utils/get-source.ts

@@ -5,11 +5,15 @@
 
 import { Format } from '#src/enums'
 import type { GetSourceOptions } from '#src/interfaces'
+import validateBoolean from '#src/internal/validate-boolean'
+import validateObject from '#src/internal/validate-object'
+import validateString from '#src/internal/validate-string'
 import type { ModuleId } from '#src/types'
 import {
   ERR_UNSUPPORTED_ESM_URL_SCHEME,
   type NodeError
 } from '@flex-development/errnode'
+import { isUndefined } from '@flex-development/tutils'
 import fs from 'node:fs/promises'
 import os from 'node:os'
 import type { URL } from 'node:url'
@@ -20,6 +24,13 @@ import toURL from './to-url'
 /**
  * Retrieves source code for the given module `id`.
  *
+ * ::: tip
+ * The given module `id` should be absolute (i.e. a [`file:` URL][1] or absolute
+ * specifier).
+ * :::
+ *
+ * [1]: https://nodejs.org/api/esm.html#file-urls
+ *
  * @see {@linkcode GetSourceOptions}
  * @see {@linkcode ModuleId}
  * @see https://nodejs.org/docs/latest-v19.x/api/esm.html#loadurl-context-nextload
@@ -36,13 +47,17 @@ const getSource = async (
   options: GetSourceOptions = {}
 ): Promise<Uint8Array | string | undefined> => {
   const {
-    base,
-    experimental_network_imports = false,
+    experimental_network_imports: network_imports = false,
     format,
     ignore_errors = false,
-    req
+    req = {}
   } = options
 
+  validateBoolean(network_imports, 'options.experimental_network_imports')
+  !isUndefined(format) && validateString(format, 'options.format')
+  validateBoolean(ignore_errors, 'options.ignore_errors')
+  !isUndefined(req) && validateObject(req, 'options.req')
+
   // exit early if format is Format.BUILTIN
   if (format === Format.BUILTIN) return undefined
 
@@ -51,7 +66,7 @@ const getSource = async (
    *
    * @const {URL} url
    */
-  const url: URL = toURL(id, base)
+  const url: URL = toURL(id)
 
   /**
    * [`ERR_UNSUPPORTED_ESM_URL_SCHEME`][1] check.
@@ -89,7 +104,7 @@ const getSource = async (
       break
     case 'http:':
     case 'https:':
-      if (experimental_network_imports) {
+      if (network_imports) {
         const { default: fetch } = await import('node-fetch')
         source = await (await fetch(url.href, req)).text()
       } else {
@@ -114,7 +129,7 @@ const getSource = async (
     const schemes: string[] = ['data', 'file']
 
     // update supported schemes if support for network based modules is enabled
-    if (experimental_network_imports) schemes.push('http', 'https')
+    if (network_imports) schemes.push('http', 'https')
 
     throw new ERR_UNSUPPORTED_ESM_URL_SCHEME(
       url,

package/src/utils/is-absolute-specifier.ts

@@ -3,6 +3,8 @@
  * @module mlly/utils/isAbsoluteSpecifier
  */
 
+import validateString from '#src/internal/validate-string'
+import type { NodeError } from '@flex-development/errnode'
 import pathe from '@flex-development/pathe'
 import { URL } from 'node:url'
 
@@ -18,8 +20,11 @@ import { URL } from 'node:url'
  *
  * @param {string} specifier - Specifier to evaluate
  * @return {boolean} `true` if `specifier` is absolute specifier
+ * @throws {NodeError<TypeError>} If `specifier` is not a string
  */
 const isAbsoluteSpecifier = (specifier: string): boolean => {
+  validateString(specifier, 'specifier')
+
   /**
    * Absolute specifier check.
    *

package/src/utils/is-bare-specifier.ts

@@ -3,6 +3,8 @@
  * @module mlly/utils/isBareSpecifier
  */
 
+import validateString from '#src/internal/validate-string'
+import type { NodeError } from '@flex-development/errnode'
 import isAbsoluteSpecifier from './is-absolute-specifier'
 import isRelativeSpecifier from './is-relative-specifier'
 
@@ -18,8 +20,11 @@ import isRelativeSpecifier from './is-relative-specifier'
  *
  * @param {string} specifier - Specifier to evaluate
  * @return {boolean} `true` if `specifier` is bare specifier
+ * @throws {NodeError<TypeError>} If `specifier` is not a string
  */
 const isBareSpecifier = (specifier: string): boolean => {
+  validateString(specifier, 'specifier')
+
   return (
     specifier.trim().length > 0 &&
     !isAbsoluteSpecifier(specifier) &&

package/src/utils/is-exports-sugar.ts

@@ -65,7 +65,7 @@ const isExportsSugar = (
       validateExports(exports, pkg, parent)
 
       // check for exports sugar
-      sugar = !Object.getOwnPropertyNames(exports)[0]?.startsWith('.')
+      sugar = !(Object.getOwnPropertyNames(exports)[0]?.startsWith('.') ?? true)
   }
 
   return sugar

package/src/utils/is-relative-specifier.ts

@@ -23,6 +23,7 @@ import pathe from '@flex-development/pathe'
  */
 const isRelativeSpecifier = (specifier: string): boolean => {
   validateString(specifier, 'specifier')
+
   return specifier.startsWith('.')
     ? specifier.length === 1 || specifier[1] === pathe.sep
       ? true

package/src/utils/parse-module-id.ts

@@ -7,6 +7,7 @@ import type { ParseModuleIdOptions, ParsedModuleId } from '#src/interfaces'
 import ENCODED_SEP_REGEX from '#src/internal/regex-encoded-sep'
 import INTERNAL_SPECIFIER_REGEX from '#src/internal/regex-internal-specifier'
 import PACKAGE_PATH_REGEX from '#src/internal/regex-package-path'
+import validateBoolean from '#src/internal/validate-boolean'
 import validateURLString from '#src/internal/validate-url-string'
 import type { ModuleId } from '#src/types'
 import {
@@ -30,9 +31,7 @@ import toNodeURL from './to-node-url'
  * @param {ModuleId} id - Module id to parse
  * @param {ParseModuleIdOptions?} [options={}] - Parsing options
  * @return {ParsedModuleId} Object representing `id`
- * @throws {NodeError<TypeError>} If `id` is not an instance of {@linkcode URL}
- * or a string, if `id` includes encoded path separators, or if `id` is invalid
- * according to `options.internal` or `options.pkgname`
+ * @throws {NodeError<TypeError>}
  */
 const parseModuleId = (
   id: ModuleId,
@@ -46,6 +45,10 @@ const parseModuleId = (
   // ensure id is an instance of URL or a string
   validateURLString(id, 'id')
 
+  // ensure option schemas
+  validateBoolean(internal, 'options.internal')
+  validateBoolean(pkgname, 'options.pkgname')
+
   // ensure id a string without leading and trailing spaces
   id = id instanceof URL ? id.href : id.trim()
 

package/src/utils/parse-subpath.ts

@@ -9,18 +9,28 @@ import type {
   ParsedSubpath
 } from '#src/interfaces'
 import getSubpaths from '#src/internal/get-subpaths'
+import isArrayIndex from '#src/internal/is-array-index'
+import invalidSegmentRegex from '#src/internal/regex-invalid-segment'
+import PACKAGE_NAME_REGEX from '#src/internal/regex-package-name'
+import validateArraySet from '#src/internal/validate-array-set'
+import validateBoolean from '#src/internal/validate-boolean'
 import validateString from '#src/internal/validate-string'
 import validateURLString from '#src/internal/validate-url-string'
 import {
+  ERR_INVALID_PACKAGE_CONFIG,
+  ERR_INVALID_PACKAGE_TARGET,
   ERR_PACKAGE_IMPORT_NOT_DEFINED,
   ERR_PACKAGE_PATH_NOT_EXPORTED,
+  ErrorCode,
   type NodeError
 } from '@flex-development/errnode'
 import pathe from '@flex-development/pathe'
 import type { Exports, Imports } from '@flex-development/pkg-types'
-import { CompareResult, type Nullable } from '@flex-development/tutils'
+import { CompareResult, isNIL, type Nullable } from '@flex-development/tutils'
 import { URL, fileURLToPath, pathToFileURL } from 'node:url'
 import compareSubpaths from './compare-subpaths'
+import CONDITIONS from './conditions'
+import isExportsSugar from './is-exports-sugar'
 import parseModuleId from './parse-module-id'
 import PATTERN_CHARACTER from './pattern-character'
 
@@ -48,21 +58,30 @@ import PATTERN_CHARACTER from './pattern-character'
  * @param {Exports | Imports | undefined} context - Package context
  * @param {ParseSubpathOptions} options - Parsing options
  * @return {ParsedSubpath} Object representing package subpath
- * @throws {NodeError<Error | TypeError>} If `specifier` is not a string or the
- * subpath defined in `specifier` is not defined in `context`
+ * @throws {NodeError<Error | TypeError>}
  */
 const parseSubpath = (
   specifier: string,
   context: Exports | Imports | undefined,
   options: ParseSubpathOptions
 ): ParsedSubpath => {
-  const { dir, internal = specifier.startsWith('#'), parent } = options
+  const {
+    condition = 'default',
+    conditions = CONDITIONS,
+    dir,
+    internal = specifier.startsWith('#'),
+    parent
+  } = options
 
   // ensure specifier is a string
   validateString(specifier, 'specifier')
 
-  // ensure dir is an instance of URL or a string
+  // ensure option schemas
+  validateString(condition, 'options.condition')
+  validateArraySet(conditions, 'options.conditions')
   validateURLString(dir, 'options.dir')
+  validateBoolean(internal, 'options.internal')
+  validateURLString(parent, 'options.parent')
 
   /**
    * Parsed module id.
@@ -156,9 +175,6 @@ const parseSubpath = (
   if (key === null) {
     let { parent } = options
 
-    // ensure parent is an instance of URL or a string
-    validateURLString(parent, 'options.parent')
-
     // ensure parent is a path
     parent = fileURLToPath(parent)
 
@@ -167,7 +183,136 @@ const parseSubpath = (
       : new ERR_PACKAGE_PATH_NOT_EXPORTED(pkgdir, id.path, parent)
   }
 
-  return { base, internal, key, raw: id.path, specifier: id.raw }
+  /**
+   * Finds the package target string specified by {@linkcode key}.
+   *
+   * @param {Exports | undefined} data - Initial package target
+   * @return {Nullable<string>} Package target string or `null`
+   * @throws {NodeError<Error | TypeError>}
+   */
+  const findPackageTarget = (data: Exports | undefined): Nullable<string> => {
+    /**
+     * Package target.
+     *
+     * @var {Nullable<string>} target
+     */
+    let target: Nullable<string> = null
+
+    switch (true) {
+      case isNIL(data):
+        target = null
+        break
+      case Array.isArray(data):
+        /**
+         * Possible package target search error.
+         *
+         * @var {NodeError | undefined} error
+         */
+        let error: NodeError | undefined
+
+        // try finding package target based on first match in search context
+        for (const item of data as string[]) {
+          try {
+            target = findPackageTarget(item)
+          } catch (e: unknown) {
+            error = e as NodeError
+
+            /* c8 ignore next */
+            if (error.code !== ErrorCode.ERR_INVALID_PACKAGE_TARGET) throw error
+
+            continue
+          }
+
+          // stop search attempts if target was found
+          if (target) {
+            error = undefined
+            break
+          }
+        }
+
+        // throw if error was encountered
+        if (error) throw error
+
+        break
+      case typeof data === 'object':
+        data = data as Record<string, Exports>
+
+        // try finding package target based on condition
+        for (const property of Object.getOwnPropertyNames(data)) {
+          if (isArrayIndex(property)) {
+            throw new ERR_INVALID_PACKAGE_CONFIG(
+              fileURLToPath(pkg),
+              fileURLToPath(parent),
+              '"exports" cannot contain numeric property keys'
+            )
+          }
+
+          // check conditions
+          if (property === condition || new Set(conditions).has(property)) {
+            target = findPackageTarget(data[property])
+            if (target) break
+          }
+        }
+
+        break
+      case typeof data === 'string':
+        target = data as string
+
+        switch (true) {
+          case internal && PACKAGE_NAME_REGEX.test(target):
+            break
+          case target.startsWith('.' + pathe.sep):
+            // check target for invalid segments
+            if (invalidSegmentRegex().test(target.slice(2))) {
+              if (invalidSegmentRegex('deprecated').test(target.slice(2))) {
+                throw new ERR_INVALID_PACKAGE_TARGET(
+                  fileURLToPath(dir),
+                  key!,
+                  target,
+                  internal,
+                  fileURLToPath(parent)
+                )
+              }
+            }
+
+            break
+          default:
+            throw new ERR_INVALID_PACKAGE_TARGET(
+              fileURLToPath(dir),
+              key!,
+              target,
+              internal,
+              fileURLToPath(parent)
+            )
+        }
+
+        break
+      default:
+        throw new ERR_INVALID_PACKAGE_TARGET(
+          fileURLToPath(dir),
+          key!,
+          data,
+          internal,
+          fileURLToPath(parent)
+        )
+    }
+
+    return target
+  }
+
+  // convert exports to object if using exports main sugar
+  if (!internal && isExportsSugar(context, pkg, parent)) {
+    context = { '.': context } as Record<string, Exports>
+  }
+
+  return {
+    base,
+    internal,
+    key,
+    raw: id.path,
+    specifier: id.raw,
+    target: findPackageTarget((context as Record<string, Exports>)[key])
+  }
 }
 
 export default parseSubpath

package/src/utils/read-package-json.ts

@@ -13,7 +13,12 @@ import {
 } from '@flex-development/errnode'
 import pathe from '@flex-development/pathe'
 import type { PackageJson } from '@flex-development/pkg-types'
-import { isEmptyString, isNIL, type Nullable } from '@flex-development/tutils'
+import {
+  isEmptyString,
+  isNIL,
+  isUndefined,
+  type Nullable
+} from '@flex-development/tutils'
 import fs from 'node:fs'
 import { fileURLToPath } from 'node:url'
 import toURL from './to-url'
@@ -44,10 +49,10 @@ const readPackageJson = (
   validateURLString(dir, 'dir')
 
   // ensure specifier is a string
-  if (specifier !== undefined) validateString(specifier, 'specifier')
+  !isUndefined(specifier) && validateString(specifier, 'specifier')
 
   // ensure parent is an instance of URL or a string
-  if (parent !== undefined) validateURLString(parent, 'parent')
+  !isUndefined(parent) && validateURLString(parent, 'parent')
 
   // ensure dir is a path
   dir = fileURLToPath(toURL(dir))

package/src/utils/resolve-alias.ts

@@ -5,9 +5,9 @@
 
 import type { ParsedModuleId, ResolveAliasOptions } from '#src/interfaces'
 import regexp from '#src/internal/escape-reg-exp'
+import validateArraySet from '#src/internal/validate-array-set'
 import validateBoolean from '#src/internal/validate-boolean'
 import validateObject from '#src/internal/validate-object'
-import validateSet from '#src/internal/validate-set'
 import validateString from '#src/internal/validate-string'
 import validateURLString from '#src/internal/validate-url-string'
 import type { NodeError } from '@flex-development/errnode'
@@ -60,8 +60,9 @@ const resolveAlias = async (
   validateBoolean(absolute, 'options.absolute')
   validateObject(aliases, 'options.aliases')
   validateString(condition, 'options.condition')
+  validateArraySet(conditions, 'options.conditions')
   validateURLString(cwd, 'options.cwd')
-  validateSet(extensions, 'options.extensions')
+  validateArraySet(extensions, 'options.extensions')
   validateURLString(parent, 'options.parent')
   validateBoolean(preserveSymlinks, 'options.preserveSymlinks')