@flex-development/mlly 1.0.0-alpha.14 → 1.0.0-alpha.16

package/dist/internal/resolver.mjs

@@ -1,13 +1,17 @@
-import CONDITIONS from "../utils/conditions.mjs";
-import isExportsSugar from "../utils/is-exports-sugar.mjs";
-import isRelativeSpecifier from "../utils/is-relative-specifier.mjs";
-import lookupPackageScope from "../utils/lookup-package-scope.mjs";
-import parseModuleId from "../utils/parse-module-id.mjs";
-import parseSubpath from "../utils/parse-subpath.mjs";
-import PATTERN_CHARACTER from "../utils/pattern-character.mjs";
-import readPackageJson from "../utils/read-package-json.mjs";
-import toNodeURL from "../utils/to-node-url.mjs";
-import toURL from "../utils/to-url.mjs";
+import {
+  CONDITIONS,
+  PATTERN_CHARACTER,
+  isDirectory,
+  isExportsSugar,
+  isFile,
+  isRelativeSpecifier,
+  lookupPackageScope,
+  parseModuleId,
+  parseSubpath,
+  readPackageJson,
+  toNodeURL,
+  toURL
+} from "../utils/index.mjs";
 import {
   ERR_INVALID_MODULE_SPECIFIER,
   ERR_INVALID_PACKAGE_CONFIG,
@@ -20,13 +24,23 @@ import {
 } from "@flex-development/errnode";
 import { isBuiltin } from "@flex-development/is-builtin";
 import pathe from "@flex-development/pathe";
-import { isNIL } from "@flex-development/tutils";
+import {
+  DOT,
+  cast,
+  get,
+  ifelse,
+  includes,
+  isArray,
+  isArrayIndex,
+  isNIL,
+  isNull,
+  isObjectCurly,
+  isString,
+  join,
+  regexp
+} from "@flex-development/tutils";
 import fs from "node:fs";
 import { URL, fileURLToPath, pathToFileURL } from "node:url";
-import regexp from "./escape-reg-exp.mjs";
-import isArrayIndex from "./is-array-index.mjs";
-import isDirectory from "./is-directory.mjs";
-import isFile from "./is-file.mjs";
 import invalidSegmentRegex from "./regex-invalid-segment.mjs";
 import PACKAGE_NAME_REGEX from "./regex-package-name.mjs";
 import PACKAGE_PATH_REGEX from "./regex-package-path.mjs";
@@ -46,17 +60,16 @@ class Resolver {
    * @return {URL} Resolved module URL
    * @throws {NodeError}
    */
-  resolveModule(specifier, parent, condition = "default", conditions = CONDITIONS, preserveSymlinks = false) {
+  resolveModule(specifier, parent, condition = "default", conditions = CONDITIONS, preserveSymlinks = !1) {
     parent = toURL(parent);
     const remote = /^https?:$/.test(parent.protocol);
     let error = new ERR_MODULE_NOT_FOUND(
       specifier,
       remote ? parent.href : fileURLToPath(parent),
       PACKAGE_PATH_REGEX.test(specifier) ? "package" : "module"
-    );
-    let url = null;
+    ), url = null;
     try {
-      switch (true) {
+      switch (!0) {
         case isRelativeSpecifier(specifier):
         case pathe.isAbsolute(specifier):
           url = new URL(specifier, parent);
@@ -73,32 +86,26 @@ class Resolver {
           try {
             url = new URL(specifier);
           } catch {
-            if (!remote) {
-              url = this.resolvePackage(
-                specifier,
-                parent,
-                condition,
-                conditions
-              );
-            }
+            remote || (url = this.resolvePackage(
+              specifier,
+              parent,
+              condition,
+              conditions
+            ));
           }
           break;
       }
       if (url && url.protocol === "file:") {
         const path = fileURLToPath(url);
-        if (!isFile(path)) {
+        if (!isFile(path))
           throw isDirectory(path) ? new ERR_UNSUPPORTED_DIR_IMPORT(path, fileURLToPath(parent)) : new ERR_MODULE_NOT_FOUND(path, fileURLToPath(parent), "module");
-        }
         if (!preserveSymlinks) {
           const { hash, search } = url;
-          url = pathToFileURL(fs.realpathSync(path));
-          url.hash = hash;
-          url.search = search;
+          url = pathToFileURL(fs.realpathSync(path)), url.hash = hash, url.search = search;
         }
       }
     } catch (e) {
-      error = e;
-      url = null;
+      error = cast(e), url = null;
     }
     if (!url)
       throw error;
@@ -128,14 +135,14 @@ class Resolver {
     });
     if (isBuiltin(id.raw))
       return new URL(toNodeURL(id.raw));
-    const stopdir = pathToFileURL("." + pathe.sep);
+    const stopdir = pathToFileURL(DOT + pathe.sep);
     let scope = lookupPackageScope(
       parent,
       stopdir,
       specifier,
       parent
     );
-    if ((scope == null ? void 0 : scope.pkgjson.name) === id.pkg && !isNIL(scope.pkgjson.exports)) {
+    if (scope?.pkgjson.name === id.pkg && !isNIL(scope.pkgjson.exports))
       return this.resolvePackageExport(
         id.raw,
         scope.pkg,
@@ -143,23 +150,18 @@ class Resolver {
         condition,
         conditions
       );
-    }
     let url = null;
     if (scope) {
       let { dir: pkgdir } = scope;
-      while (pkgdir !== ".") {
-        scope = lookupPackageScope(
-          new URL(`node_modules/${id.raw}`, pkgdir + pathe.sep),
-          stopdir,
-          specifier,
-          parent
-        );
-        if (scope)
-          break;
+      for (; pkgdir !== DOT && (scope = lookupPackageScope(
+        new URL(`node_modules/${id.raw}`, pkgdir + pathe.sep),
+        stopdir,
+        specifier,
+        parent
+      ), !scope); )
         pkgdir = pathe.dirname(pkgdir);
-      }
     }
-    switch (true) {
+    switch (!0) {
       case (scope && !isNIL(scope.pkgjson.exports)):
         url = this.resolvePackageExport(
           specifier,
@@ -169,7 +171,7 @@ class Resolver {
           conditions
         );
         break;
-      case (scope && id.path === "."):
+      case (scope && id.path === DOT):
         url = this.resolvePackageMain(scope.pkg, scope.pkgjson, parent);
         break;
       case !!scope:
@@ -198,23 +200,20 @@ class Resolver {
    * @throws {NodeError<Error | TypeError>}
    */
   resolvePackageExport(specifier, pkg, parent, condition = "default", conditions = CONDITIONS) {
-    const dir = new URL(".", pkg);
-    const pkgjson = readPackageJson(
+    const dir = new URL(DOT, pkg);
+    let exports = readPackageJson(
       dir,
       specifier,
       parent
-    );
-    let exports = pkgjson == null ? void 0 : pkgjson.exports;
+    )?.exports;
     const subpath = parseSubpath(specifier, exports, {
       dir,
       parent
     });
-    if (!subpath.internal && isExportsSugar(exports, pkg, parent)) {
-      exports = { ".": exports };
-    }
+    !subpath.internal && isExportsSugar(exports, pkg, parent) && (exports = cast({ [DOT]: exports }));
     const url = this.resolvePackageTarget(
       dir,
-      exports == null ? void 0 : exports[subpath.key],
+      get(exports, subpath.key),
       subpath.base,
       subpath.key,
       parent,
@@ -222,13 +221,12 @@ class Resolver {
       condition,
       conditions
     );
-    if (!url) {
+    if (!url)
       throw new ERR_PACKAGE_PATH_NOT_EXPORTED(
         fileURLToPath(dir),
         subpath.raw,
         fileURLToPath(parent)
       );
-    }
     return url;
   }
   /**
@@ -249,26 +247,24 @@ class Resolver {
    */
   resolvePackageImport(specifier, parent, condition = "default", conditions = CONDITIONS) {
     const id = parseModuleId(specifier, {
-      internal: true,
+      internal: !0,
       parent
-    });
-    const scope = lookupPackageScope(
+    }), scope = lookupPackageScope(
       parent,
-      pathToFileURL("."),
+      pathToFileURL(DOT),
       specifier,
       parent
     );
     let url = null;
     if (scope) {
-      const imports = scope.pkgjson.imports;
-      const subpath = parseSubpath(id.raw, imports, {
+      const imports = scope.pkgjson.imports, subpath = parseSubpath(id.raw, imports, {
         dir: scope.dir,
-        internal: true,
+        internal: !0,
         parent
       });
       url = this.resolvePackageTarget(
         scope.dir,
-        imports == null ? void 0 : imports[subpath.key],
+        get(imports, cast(subpath.key)),
         subpath.base,
         subpath.key,
         parent,
@@ -277,14 +273,13 @@ class Resolver {
         conditions
       );
     }
-    if (!url) {
+    if (!url)
       throw new ERR_PACKAGE_IMPORT_NOT_DEFINED(
         specifier,
         fileURLToPath(parent),
         /* c8 ignore next */
-        (scope == null ? void 0 : scope.dir) ? fileURLToPath(scope.dir) : void 0
+        scope?.dir ? fileURLToPath(scope.dir) : void 0
       );
-    }
     return url;
   }
   /**
@@ -327,12 +322,11 @@ class Resolver {
         break;
       url = null;
     }
-    if (!url) {
+    if (!url)
       throw new ERR_MODULE_NOT_FOUND(
-        fileURLToPath(new URL(".", pkg)),
+        fileURLToPath(new URL(DOT, pkg)),
         fileURLToPath(parent)
       );
-    }
     return url;
   }
   /**
@@ -346,7 +340,7 @@ class Resolver {
    * @public
    *
    * @param {ModuleId} dir - URL of directory containing relevant `package.json`
-   * @param {Exports | undefined} target - Package `exports` or `imports` target
+   * @param {Optional<Exports>} target - Package `exports` or `imports` target
    * @param {string} subpath - Package subpath without entry prefix (`key`)
    * @param {string} key - Subpath defined in relevant `package.json` file
    * @param {ModuleId} parent - URL of module to resolve from
@@ -356,14 +350,14 @@ class Resolver {
    * @return {Nullable<URL>} Resolved package target URL or `null`
    * @throws {NodeError<Error | TypeError>}
    */
-  resolvePackageTarget(dir, target, subpath, key, parent, internal = false, condition = "default", conditions = CONDITIONS) {
+  resolvePackageTarget(dir, target, subpath, key, parent, internal = !1, condition = "default", conditions = CONDITIONS) {
     let url = null;
-    switch (true) {
-      case target === null:
+    switch (!0) {
+      case isNull(target):
         break;
-      case Array.isArray(target):
+      case isArray(target):
         let error;
-        for (const item of target) {
+        for (const item of cast(target)) {
           try {
             url = this.resolvePackageTarget(
               dir,
@@ -376,8 +370,7 @@ class Resolver {
               conditions
             );
           } catch (e) {
-            error = e;
-            if (error.code !== ErrorCode.ERR_INVALID_PACKAGE_TARGET)
+            if (error = cast(e), error.code !== ErrorCode.ERR_INVALID_PACKAGE_TARGET)
               throw error;
             continue;
           }
@@ -389,36 +382,32 @@ class Resolver {
         if (error)
           throw error;
         break;
-      case typeof target === "object":
-        target = target;
+      case isObjectCurly(target):
+        target = cast(target);
         for (const prop of Object.getOwnPropertyNames(target)) {
-          if (isArrayIndex(prop)) {
+          if (isArrayIndex(prop))
             throw new ERR_INVALID_PACKAGE_CONFIG(
               fileURLToPath(dir).replace(/\/$/, "") + "/package.json",
               fileURLToPath(parent),
               '"exports" cannot contain numeric property keys'
             );
-          }
-          if (prop === condition || conditions.has(prop)) {
-            url = this.resolvePackageTarget(
-              dir,
-              target[prop],
-              subpath,
-              key,
-              parent,
-              internal,
-              condition,
-              conditions
-            );
-            if (url)
-              break;
-          }
+          if ((prop === condition || conditions.has(prop)) && (url = this.resolvePackageTarget(
+            dir,
+            get(target, prop),
+            subpath,
+            key,
+            parent,
+            internal,
+            condition,
+            conditions
+          ), url))
+            break;
         }
         break;
-      case typeof target === "string":
-        target = target;
-        const pattern = key.includes(PATTERN_CHARACTER);
-        switch (true) {
+      case isString(target):
+        target = cast(target);
+        const pattern = includes(key, PATTERN_CHARACTER);
+        switch (!0) {
           case (subpath && !pattern && !target.endsWith(pathe.sep)):
             throw new ERR_INVALID_PACKAGE_TARGET(
               fileURLToPath(dir),
@@ -430,36 +419,33 @@ class Resolver {
           case (internal && PACKAGE_NAME_REGEX.test(target)):
             url = this.resolvePackage(target, parent, condition, conditions);
             break;
-          case target.startsWith("." + pathe.sep):
-            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)
-                );
-              }
-            }
-            url = new URL(
+          case target.startsWith(DOT + pathe.sep):
+            if (invalidSegmentRegex().test(target.slice(2)) && invalidSegmentRegex("deprecated").test(target.slice(2)))
+              throw new ERR_INVALID_PACKAGE_TARGET(
+                fileURLToPath(dir),
+                key,
+                target,
+                internal,
+                fileURLToPath(parent)
+              );
+            if (url = new URL(
               target,
               pathToFileURL(fileURLToPath(dir).replace(/\/$/, "") + pathe.sep)
-            );
-            if (subpath) {
-              if (invalidSegmentRegex().test(subpath)) {
-                if (invalidSegmentRegex("deprecated").test(subpath)) {
-                  throw new ERR_INVALID_MODULE_SPECIFIER(
-                    key.replace(PATTERN_CHARACTER, subpath),
+            ), subpath) {
+              if (invalidSegmentRegex().test(subpath) && invalidSegmentRegex("deprecated").test(subpath))
+                throw new ERR_INVALID_MODULE_SPECIFIER(
+                  key.replace(PATTERN_CHARACTER, subpath),
+                  join(
                     [
                       `request is not a valid match in pattern "${key}" for`,
-                      `the "${internal ? "imports" : "exports"}" resolution`,
-                      `of ${fileURLToPath(dir).replace(/\/$/, "")}/package.json`
-                    ].join(" "),
-                    fileURLToPath(parent)
-                  );
-                }
-              }
+                      `the "${ifelse(internal, "imports", "exports")}"`,
+                      "resolution of",
+                      `${fileURLToPath(dir).replace(/\/$/, "")}/package.json`
+                    ],
+                    " "
+                  ),
+                  fileURLToPath(parent)
+                );
               url = new URL(
                 url.href.replace(
                   new RegExp(regexp(PATTERN_CHARACTER), "g"),
@@ -494,4 +480,3 @@ var resolver_default = Resolver;
 export {
   resolver_default as default
 };
-//# sourceMappingURL=resolver.mjs.map

package/dist/internal/validate-array-set.d.mts

@@ -3,7 +3,7 @@
  * @module mlly/internal/validateArraySet
  */
 /**
- * Checks if given `value` is an array or a {@linkcode Set}.
+ * Checks if `value` is an array or an instance of {@linkcode Set}.
  *
  * Throws [`ERR_INVALID_ARG_TYPE`][1] if the `value` is of neither type.
  *
@@ -11,12 +11,14 @@
  *
  * @see {@linkcode ERR_INVALID_ARG_TYPE}
  *
- * @template T - Item type(s)
+ * @internal
+ *
+ * @template T - Item type
  *
  * @param {unknown} value - Value supplied by user
  * @param {string} name - Name of invalid argument or property
- * @return {value is Set<T> | T[]} `true` if `value` is array or {@linkcode Set}
- * @throws {NodeError<TypeError>} If `value` is not an array or {@linkcode Set}
+ * @return {value is Set<T> | T[]} `true` if `value` is array or `Set`
+ * @throws {NodeError<TypeError>} If `value` is not an array or `Set`
  */
-declare function validateArraySet<T = unknown>(value: unknown, name: string): value is Set<T> | T[];
+declare const validateArraySet: <T>(value: unknown, name: string) => value is Set<T> | T[];
 export default validateArraySet;

package/dist/internal/validate-array-set.mjs

@@ -1,11 +1,11 @@
 import { ERR_INVALID_ARG_TYPE } from "@flex-development/errnode";
-function validateArraySet(value, name) {
-  if (Array.isArray(value) || value instanceof Set)
-    return true;
+import { isArray, isSet } from "@flex-development/tutils";
+const validateArraySet = (value, name) => {
+  if (isArray(value) || isSet(value))
+    return !0;
   throw new ERR_INVALID_ARG_TYPE(name, ["Array", "Set"], value);
-}
+};
 var validate_array_set_default = validateArraySet;
 export {
   validate_array_set_default as default
 };
-//# sourceMappingURL=validate-array-set.mjs.map

package/dist/internal/validate-boolean.d.mts

@@ -3,14 +3,16 @@
  * @module mlly/internal/validateBoolean
  */
 /**
- * Checks if given `value` is a boolean.
+ * Checks if `value` is a boolean.
  *
- * Throws [`ERR_INVALID_ARG_TYPE`][1] if the `value` is not a boolean.
+ * Throws [`ERR_INVALID_ARG_TYPE`][1] if `value` is not a boolean.
  *
  * [1]: https://nodejs.org/api/errors.html#err_invalid_arg_value
  *
  * @see {@linkcode ERR_INVALID_ARG_TYPE}
  *
+ * @internal
+ *
  * @param {unknown} value - Value supplied by user
  * @param {string} name - Name of invalid argument or property
  * @return {value is boolean} `true` if `value` is a boolean

package/dist/internal/validate-boolean.mjs

@@ -1,11 +1,11 @@
 import { ERR_INVALID_ARG_TYPE } from "@flex-development/errnode";
+import { isBoolean } from "@flex-development/tutils";
 const validateBoolean = (value, name) => {
-  if (typeof value === "boolean")
-    return true;
+  if (isBoolean(value))
+    return !0;
   throw new ERR_INVALID_ARG_TYPE(name, "boolean", value);
 };
 var validate_boolean_default = validateBoolean;
 export {
   validate_boolean_default as default
 };
-//# sourceMappingURL=validate-boolean.mjs.map

package/dist/internal/validate-map.d.mts

@@ -2,22 +2,25 @@
  * @file Internal - validateMap
  * @module mlly/internal/validateMap
  */
+import { type PropertyKey } from '@flex-development/tutils';
 /**
- * Checks if given `value` is a {@linkcode Map}.
+ * Checks if `value` is a {@linkcode Map} instance.
  *
- * Throws [`ERR_INVALID_ARG_TYPE`][1] if the `value` is not a {@linkcode Map}.
+ * Throws [`ERR_INVALID_ARG_TYPE`][1] if `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)
+ * @internal
+ *
+ * @template K - Map key type
+ * @template V - Map item type
  *
  * @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}
+ * @return {value is Map<K, V>} `true` if `value` is a `Map`
+ * @throws {NodeError<TypeError>} If `value` is not a `Map`
  */
-declare function validateMap<K extends string = string, V = unknown>(value: unknown, name: string): value is Map<K, V>;
+declare const validateMap: <K = PropertyKey, V = unknown>(value: unknown, name: string) => value is Map<K, V>;
 export default validateMap;

package/dist/internal/validate-map.mjs

@@ -1,11 +1,11 @@
 import { ERR_INVALID_ARG_TYPE } from "@flex-development/errnode";
-function validateMap(value, name) {
-  if (value instanceof Map)
-    return true;
+import { isMap } from "@flex-development/tutils";
+const validateMap = (value, name) => {
+  if (isMap(value))
+    return !0;
   throw new ERR_INVALID_ARG_TYPE(name, ["Map"], value);
-}
+};
 var validate_map_default = validateMap;
 export {
   validate_map_default as default
 };
-//# sourceMappingURL=validate-map.mjs.map

package/dist/internal/validate-object.d.mts

@@ -2,22 +2,22 @@
  * @file Internal - validateObject
  * @module mlly/internal/validateObject
  */
-import type { ObjectPlain } from '@flex-development/tutils';
+import { type ObjectCurly } from '@flex-development/tutils';
 /**
- * Checks if given `value` is an object.
+ * Checks if `value` is a curly-braced object.
  *
- * **Note**: Array values are not considered objects.
- *
- * Throws [`ERR_INVALID_ARG_TYPE`][1] if the `value` is not an object.
+ * Throws [`ERR_INVALID_ARG_TYPE`][1] if `value` is not a curly-braced object.
  *
  * [1]: https://nodejs.org/api/errors.html#err_invalid_arg_value
  *
- * @see {@linkcode ERR_INVALID_ARG_TYPE}
+ * @see {@linkcode isObjectCurly}
+ *
+ * @internal
  *
  * @param {unknown} value - Value supplied by user
  * @param {string} name - Name of invalid argument or property
- * @return {value is ObjectPlain} `true` if `value` is an object
- * @throws {NodeError<TypeError>} If `value` is not an object
+ * @return {value is ObjectCurly} `true` if `value` is a curly-braced object
+ * @throws {NodeError<TypeError>} If `value` is not a curly-braced object
  */
-declare const validateObject: (value: unknown, name: string) => value is ObjectPlain;
+declare const validateObject: (value: unknown, name: string) => value is ObjectCurly;
 export default validateObject;

package/dist/internal/validate-object.mjs

@@ -1,11 +1,11 @@
 import { ERR_INVALID_ARG_TYPE } from "@flex-development/errnode";
+import { isObjectCurly } from "@flex-development/tutils";
 const validateObject = (value, name) => {
-  if (typeof value === "object" && value && !Array.isArray(value))
-    return true;
+  if (isObjectCurly(value))
+    return !0;
   throw new ERR_INVALID_ARG_TYPE(name, "object", value);
 };
 var validate_object_default = validateObject;
 export {
   validate_object_default as default
 };
-//# sourceMappingURL=validate-object.mjs.map

package/dist/internal/validate-set.d.mts

@@ -5,18 +5,20 @@
 /**
  * Checks if given `value` is a {@linkcode Set}.
  *
- * Throws [`ERR_INVALID_ARG_TYPE`][1] if the `value` is not a {@linkcode Set}.
+ * Throws [`ERR_INVALID_ARG_TYPE`][1] if `value` is not a {@linkcode Set}.
  *
  * [1]: https://nodejs.org/api/errors.html#err_invalid_arg_value
  *
  * @see {@linkcode ERR_INVALID_ARG_TYPE}
  *
- * @template T - Item type(s)
+ * @internal
+ *
+ * @template T - Set item type
  *
  * @param {unknown} value - Value supplied by user
  * @param {string} name - Name of invalid argument or property
- * @return {value is Set<T>} `true` if `value` is a {@linkcode Set}
- * @throws {NodeError<TypeError>} If `value` is not a {@linkcode Set}
+ * @return {value is Set<T>} `true` if `value` is a `Set`
+ * @throws {NodeError<TypeError>} If `value` is not a `Set`
  */
-declare function validateSet<T = unknown>(value: unknown, name: string): value is Set<T>;
+declare const validateSet: <T>(value: unknown, name: string) => value is Set<T>;
 export default validateSet;

package/dist/internal/validate-set.mjs

@@ -1,11 +1,11 @@
 import { ERR_INVALID_ARG_TYPE } from "@flex-development/errnode";
-function validateSet(value, name) {
-  if (value instanceof Set)
-    return true;
+import { isSet } from "@flex-development/tutils";
+const validateSet = (value, name) => {
+  if (isSet(value))
+    return !0;
   throw new ERR_INVALID_ARG_TYPE(name, ["Set"], value);
-}
+};
 var validate_set_default = validateSet;
 export {
   validate_set_default as default
 };
-//# sourceMappingURL=validate-set.mjs.map