@markuplint/file-resolver 3.15.0 → 4.0.0-alpha.10

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2019 Yusuke Hirao
+Copyright (c) 2017-2024 Yusuke Hirao
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/lib/auto-load-rules.d.ts

@@ -3,6 +3,6 @@ import type { Ruleset, AnyMLRule } from '@markuplint/ml-core';
  * @deprecated
  */
 export declare function autoLoadRules(ruleset: Ruleset): Promise<{
-	rules: AnyMLRule[];
-	errors: unknown[];
+    rules: AnyMLRule[];
+    errors: unknown[];
 }>;

package/lib/auto-load-rules.js

@@ -1,35 +1,9 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.autoLoadRules = void 0;
-const ml_core_1 = require("@markuplint/ml-core");
+import { MLRule } from '@markuplint/ml-core';
 const cache = new Map();
 /**
  * @deprecated
  */
-async function autoLoadRules(ruleset) {
+export async function autoLoadRules(ruleset) {
     const rules = [];
     const errors = [];
     for (const ruleName of Object.keys(ruleset.rules)) {
@@ -40,17 +14,17 @@ async function autoLoadRules(ruleset) {
         }
         let seed = null;
         try {
-            const _module = await Promise.resolve(`${`@markuplint/rule-${ruleName}`}`).then(s => __importStar(require(s)));
+            const _module = await import(`@markuplint/rule-${ruleName}`);
             seed = _module.default;
             if (!(seed && 'defaultValue' in seed && 'defaultOptions' in seed && 'verify' in seed)) {
                 seed = null;
             }
         }
-        catch (e) {
-            errors.push(e);
+        catch (error) {
+            errors.push(error);
         }
         if (seed) {
-            const rule = new ml_core_1.MLRule({
+            const rule = new MLRule({
                 name: ruleName,
                 ...seed,
             });
@@ -59,17 +33,17 @@ async function autoLoadRules(ruleset) {
             continue;
         }
         try {
-            const _module = await Promise.resolve(`${`markuplint-rule-${ruleName}`}`).then(s => __importStar(require(s)));
+            const _module = await import(`markuplint-rule-${ruleName}`);
             seed = _module.default;
             if (!(seed && 'defaultValue' in seed && 'defaultOptions' in seed && 'verify' in seed)) {
                 seed = null;
             }
         }
-        catch (e) {
-            errors.push(e);
+        catch (error) {
+            errors.push(error);
         }
         if (seed) {
-            const rule = new ml_core_1.MLRule({
+            const rule = new MLRule({
                 name: ruleName,
                 ...seed,
             });
@@ -80,9 +54,8 @@ async function autoLoadRules(ruleset) {
     }
     return {
         // Clone
-        rules: rules.slice(),
+        rules: [...rules],
         // Clone
-        errors: errors.slice(),
+        errors: [...errors],
     };
 }
-exports.autoLoadRules = autoLoadRules;

package/lib/config-load-error.d.ts

@@ -0,0 +1,6 @@
+export declare class ConfigLoadError extends Error {
+    filePath: string;
+    name: string;
+    referrer: string;
+    constructor(message: string, filePath: string, referrer: string);
+}

package/lib/config-load-error.js

@@ -0,0 +1,8 @@
+export class ConfigLoadError extends Error {
+    constructor(message, filePath, referrer) {
+        super(message + ` in ${referrer}`);
+        this.name = 'ConfigLoadError';
+        this.filePath = filePath;
+        this.referrer = referrer;
+    }
+}

package/lib/config-provider.d.ts

@@ -1,15 +1,18 @@
-import type { MLFile } from './ml-file';
-import type { ConfigSet } from './types';
+import type { MLFile } from './ml-file/index.js';
+import type { ConfigSet } from './types.js';
 import type { Config } from '@markuplint/ml-config';
 import type { Nullable } from '@markuplint/shared';
 export declare class ConfigProvider {
-	#private;
-	resolve(targetFile: Readonly<MLFile>, names: readonly Nullable<string>[], cache?: boolean): Promise<ConfigSet>;
-	search(targetFile: Readonly<MLFile>): Promise<string | null>;
-	set(config: Config, key?: string): string;
-	private _load;
-	private _mergeConfigs;
-	private _pathResolve;
-	private _recursiveLoad;
-	private _validateConfig;
+    #private;
+    recursiveLoad(key: string, cache: boolean, referrer: string, depth?: number): Promise<{
+        stack: Set<string>;
+        errs: Error[];
+    }>;
+    resolve(targetFile: Readonly<MLFile>, names: readonly Nullable<string>[], cache?: boolean): Promise<ConfigSet>;
+    search(targetFile: Readonly<MLFile>): Promise<string | null>;
+    set(config: Config, key?: string): string;
+    private _load;
+    private _mergeConfigs;
+    private _pathResolve;
+    private _validateConfig;
 }

package/lib/config-provider.js

@@ -1,56 +1,102 @@
-"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 var _ConfigProvider_cache, _ConfigProvider_held, _ConfigProvider_recursiveLoadKeyAndDepth, _ConfigProvider_store;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigProvider = void 0;
-const tslib_1 = require("tslib");
-const path_1 = tslib_1.__importDefault(require("path"));
-const ml_config_1 = require("@markuplint/ml-config");
-const ml_core_1 = require("@markuplint/ml-core");
-const parser_utils_1 = require("@markuplint/parser-utils");
-const selector_1 = require("@markuplint/selector");
-const shared_1 = require("@markuplint/shared");
-const cosmiconfig_1 = require("./cosmiconfig");
-const resolve_plugins_1 = require("./resolve-plugins");
-const utils_1 = require("./utils");
+import path from 'node:path';
+import { mergeConfig } from '@markuplint/ml-config';
+import { ConfigParserError } from '@markuplint/parser-utils';
+import { InvalidSelectorError, createSelector } from '@markuplint/selector';
+import { nonNullableFilter, toNoEmptyStringArrayFromStringOrArray } from '@markuplint/shared';
+import { ConfigLoadError } from './config-load-error.js';
+import { load as loadConfig, search } from './cosmiconfig.js';
+import { log } from './debug.js';
+import { generalImport } from './general-import.js';
+import { getPreset } from './get-preset.js';
+import { isPluginModuleName } from './is-plugin-module-name.js';
+import { isPresetModuleName } from './is-preset-module-name.js';
+import { moduleExists } from './module-exists.js';
+import { relPathToNameOrAbsPath } from './path-to-abs-or-name.js';
+import { cacheClear, resolvePlugins } from './resolve-plugins.js';
+import { fileExists, uuid } from './utils.js';
+const cpLog = log.extend('config-provider');
 const KEY_SEPARATOR = '__ML_CONFIG_MERGE__';
-class ConfigProvider {
+export class ConfigProvider {
     constructor() {
         _ConfigProvider_cache.set(this, new Map());
         _ConfigProvider_held.set(this, new Set());
         _ConfigProvider_recursiveLoadKeyAndDepth.set(this, new Map());
         _ConfigProvider_store.set(this, new Map());
     }
+    async recursiveLoad(key, cache, referrer, depth = 1) {
+        const stack = new Set();
+        const errs = [];
+        const ancestorDepth = __classPrivateFieldGet(this, _ConfigProvider_recursiveLoadKeyAndDepth, "f").get(key);
+        if (ancestorDepth != null && ancestorDepth < depth) {
+            return {
+                stack,
+                errs: [new CircularReferenceError(`Circular reference detected: ${key}`)],
+            };
+        }
+        __classPrivateFieldGet(this, _ConfigProvider_recursiveLoadKeyAndDepth, "f").set(key, depth);
+        let config = __classPrivateFieldGet(this, _ConfigProvider_store, "f").get(key);
+        if (!config) {
+            config = await this._load(key, cache, referrer);
+        }
+        if (!config) {
+            return { stack, errs: [] };
+        }
+        if (config instanceof ConfigLoadError) {
+            stack.add(config.filePath);
+            return {
+                stack,
+                errs: [config],
+            };
+        }
+        const depKeys = config.extends === null ? null : toNoEmptyStringArrayFromStringOrArray(config.extends);
+        if (depKeys) {
+            for (const depKey of depKeys) {
+                const keys = await this.recursiveLoad(depKey, cache, key, depth + 1);
+                for (const key of keys.stack) {
+                    stack.add(key);
+                }
+                errs.push(...keys.errs);
+            }
+        }
+        stack.add(key);
+        return { stack, errs };
+    }
     async resolve(targetFile, names, cache = true) {
-        var _a, _b;
         if (!cache) {
-            tslib_1.__classPrivateFieldGet(this, _ConfigProvider_store, "f").clear();
-            tslib_1.__classPrivateFieldGet(this, _ConfigProvider_cache, "f").clear();
-            (0, resolve_plugins_1.cacheClear)();
+            __classPrivateFieldGet(this, _ConfigProvider_store, "f").clear();
+            __classPrivateFieldGet(this, _ConfigProvider_cache, "f").clear();
+            cacheClear();
         }
-        const keys = names.filter(shared_1.nonNullableFilter);
+        const keys = names.filter(nonNullableFilter);
         const key = keys.join(KEY_SEPARATOR);
-        const currentConfig = tslib_1.__classPrivateFieldGet(this, _ConfigProvider_cache, "f").get(key);
+        const currentConfig = __classPrivateFieldGet(this, _ConfigProvider_cache, "f").get(key);
         if (currentConfig) {
             return currentConfig;
         }
-        let configSet = await this._mergeConfigs(keys, cache);
-        const filePath = Array.from(configSet.files).reverse()[0];
+        let configSet = await this._mergeConfigs(keys, cache, targetFile.path);
+        const filePath = [...configSet.files].reverse()[0];
         if (!filePath) {
-            throw new parser_utils_1.ConfigParserError('Config file not found', {
+            throw new ConfigParserError('Config file not found', {
                 filePath: targetFile.path,
             });
         }
         const errors = this._validateConfig(configSet.config, filePath);
         configSet.errs.push(...errors);
-        const plugins = await (0, resolve_plugins_1.resolvePlugins)(configSet.config.plugins);
-        if (tslib_1.__classPrivateFieldGet(this, _ConfigProvider_held, "f").size > 0) {
-            const extendHelds = Array.from(tslib_1.__classPrivateFieldGet(this, _ConfigProvider_held, "f").values());
+        const plugins = await resolvePlugins(configSet.config.plugins);
+        if (__classPrivateFieldGet(this, _ConfigProvider_held, "f").size > 0) {
+            const extendHelds = [...__classPrivateFieldGet(this, _ConfigProvider_held, "f").values()];
             for (const held of extendHelds) {
-                const [, prefix, namespace, name] = (_a = held.match(/^([a-z]+:)([^/]+)(?:\/(.+))?$/)) !== null && _a !== void 0 ? _a : [];
+                const [, prefix, namespace, name] = held.match(/^([a-z]+:)([^/]+)(?:\/(.+))?$/) ?? [];
                 switch (prefix) {
                     case 'plugin:': {
                         const plugin = plugins.find(plugin => plugin.name === namespace);
-                        const config = (_b = plugin === null || plugin === void 0 ? void 0 : plugin.configs) === null || _b === void 0 ? void 0 : _b[name !== null && name !== void 0 ? name : ''];
+                        const config = plugin?.configs?.[name ?? ''];
                         if (config) {
                             this.set(config, held);
                         }
@@ -58,8 +104,8 @@ class ConfigProvider {
                     }
                 }
             }
-            configSet = await this._mergeConfigs([...keys, ...extendHelds], cache);
-            tslib_1.__classPrivateFieldGet(this, _ConfigProvider_held, "f").clear();
+            configSet = await this._mergeConfigs([...keys, ...extendHelds], cache, targetFile.path);
+            __classPrivateFieldGet(this, _ConfigProvider_held, "f").clear();
         }
         // Resolves `overrides`
         if (configSet.config.overrides) {
@@ -78,74 +124,78 @@ class ConfigProvider {
             ...configSet,
             plugins,
         };
-        tslib_1.__classPrivateFieldGet(this, _ConfigProvider_cache, "f").set(key, result);
+        __classPrivateFieldGet(this, _ConfigProvider_cache, "f").set(key, result);
         return result;
     }
     async search(targetFile) {
-        if (!(await targetFile.dirExists())) {
+        const isExists = await targetFile.dirExists();
+        cpLog('search: %s', targetFile.path);
+        cpLog('isExists: %s', isExists);
+        if (!isExists) {
             return null;
         }
-        const res = await (0, cosmiconfig_1.search)(targetFile.path, false);
+        const res = await search(targetFile.path, false);
+        cpLog('searched config: %O', res);
         if (!res) {
             return null;
         }
         const { filePath, config } = res;
-        const pathResolvedConfig = this._pathResolve(config, filePath);
-        tslib_1.__classPrivateFieldGet(this, _ConfigProvider_store, "f").set(filePath, pathResolvedConfig);
+        const pathResolvedConfig = await this._pathResolve(config, filePath);
+        __classPrivateFieldGet(this, _ConfigProvider_store, "f").set(filePath, pathResolvedConfig);
+        cpLog('Store key: %s', filePath);
         return filePath;
     }
     set(config, key) {
-        key = key !== null && key !== void 0 ? key : (0, utils_1.uuid)();
-        tslib_1.__classPrivateFieldGet(this, _ConfigProvider_store, "f").set(key, config);
+        key = key ?? uuid();
+        __classPrivateFieldGet(this, _ConfigProvider_store, "f").set(key, config);
         return key;
     }
-    async _load(filePath, cache) {
-        var _a;
-        const entity = tslib_1.__classPrivateFieldGet(this, _ConfigProvider_store, "f").get(filePath);
+    async _load(filePath, cache, referrer) {
+        const entity = __classPrivateFieldGet(this, _ConfigProvider_store, "f").get(filePath);
         if (entity) {
             return entity;
         }
-        if (isPreset(filePath)) {
-            const [, name] = (_a = filePath.match(/^markuplint:(.+)$/i)) !== null && _a !== void 0 ? _a : [];
-            const config = await (0, ml_core_1.getPreset)(name !== null && name !== void 0 ? name : filePath);
-            const pathResolvedConfig = this._pathResolve(config, filePath);
-            tslib_1.__classPrivateFieldGet(this, _ConfigProvider_store, "f").set(filePath, pathResolvedConfig);
+        if (isPresetModuleName(filePath)) {
+            const [, name] = filePath.match(/^markuplint:(.+)$/i) ?? [];
+            const config = await getPreset(name ?? filePath);
+            const pathResolvedConfig = await this._pathResolve(config, filePath);
+            __classPrivateFieldGet(this, _ConfigProvider_store, "f").set(filePath, pathResolvedConfig);
             return pathResolvedConfig;
         }
-        if (isPlugin(filePath)) {
-            tslib_1.__classPrivateFieldGet(this, _ConfigProvider_held, "f").add(filePath);
-            return null;
+        if (isPluginModuleName(filePath)) {
+            __classPrivateFieldGet(this, _ConfigProvider_held, "f").add(filePath);
+            return;
         }
-        if (!moduleExists(filePath) && !path_1.default.isAbsolute(filePath)) {
+        if (!(await moduleExists(filePath)) && !path.isAbsolute(filePath)) {
             throw new TypeError(`${filePath} is not an absolute path`);
         }
-        const config = await load(filePath, cache);
-        if (!config) {
-            return null;
+        const config = await load(filePath, cache, referrer);
+        if (config instanceof ConfigLoadError) {
+            return config;
         }
-        const pathResolvedConfig = this._pathResolve(config, filePath);
-        tslib_1.__classPrivateFieldGet(this, _ConfigProvider_store, "f").set(filePath, pathResolvedConfig);
+        const pathResolvedConfig = await this._pathResolve(config, filePath);
+        __classPrivateFieldGet(this, _ConfigProvider_store, "f").set(filePath, pathResolvedConfig);
         return pathResolvedConfig;
     }
-    async _mergeConfigs(keys, cache) {
+    async _mergeConfigs(keys, cache, referrer) {
         const resolvedKeys = new Set();
         const errs = [];
         for (const key of keys) {
-            tslib_1.__classPrivateFieldGet(this, _ConfigProvider_recursiveLoadKeyAndDepth, "f").clear();
-            const keySet = await this._recursiveLoad(key, cache);
+            __classPrivateFieldGet(this, _ConfigProvider_recursiveLoadKeyAndDepth, "f").clear();
+            const keySet = await this.recursiveLoad(key, cache, referrer);
             for (const k of keySet.stack) {
                 resolvedKeys.add(k);
             }
-            if (keySet.errs) {
-                errs.push(...keySet.errs);
-            }
+            errs.push(...keySet.errs);
         }
-        const configs = Array.from(resolvedKeys)
-            .map(name => tslib_1.__classPrivateFieldGet(this, _ConfigProvider_store, "f").get(name))
-            .filter(shared_1.nonNullableFilter);
+        const configs = [...resolvedKeys].map(name => __classPrivateFieldGet(this, _ConfigProvider_store, "f").get(name)).filter(nonNullableFilter);
         let resultConfig = {};
         for (const config of configs) {
-            resultConfig = (0, ml_config_1.mergeConfig)(resultConfig, config);
+            if (config instanceof ConfigLoadError) {
+                errs.push(config);
+                continue;
+            }
+            resultConfig = mergeConfig(resultConfig, config);
         }
         return {
             config: resultConfig,
@@ -153,157 +203,55 @@ class ConfigProvider {
             errs,
         };
     }
-    _pathResolve(config, filePath) {
-        const dir = path_1.default.dirname(filePath);
+    async _pathResolve(config, filePath) {
+        const dir = path.dirname(filePath);
         return {
             ...config,
-            extends: pathResolve(dir, config.extends),
-            plugins: pathResolve(dir, config.plugins, ['name']),
-            parser: pathResolve(dir, config.parser),
-            specs: pathResolve(dir, config.specs),
-            excludeFiles: pathResolve(dir, config.excludeFiles),
-            overrides: pathResolve(dir, config.overrides, undefined, true),
+            extends: await relPathToNameOrAbsPath(dir, config.extends),
+            plugins: await relPathToNameOrAbsPath(dir, config.plugins, ['name']),
+            parser: await relPathToNameOrAbsPath(dir, config.parser),
+            specs: await relPathToNameOrAbsPath(dir, config.specs),
+            excludeFiles: await relPathToNameOrAbsPath(dir, config.excludeFiles),
+            overrides: await relPathToNameOrAbsPath(dir, config.overrides, undefined, true),
         };
     }
-    async _recursiveLoad(key, cache, depth = 1) {
-        var _a;
-        const stack = new Set();
-        const errs = [];
-        const ancestorDepth = tslib_1.__classPrivateFieldGet(this, _ConfigProvider_recursiveLoadKeyAndDepth, "f").get(key);
-        if (ancestorDepth != null && ancestorDepth < depth) {
-            return {
-                stack,
-                errs: [new CircularReferenceError(`Circular reference detected: ${key}`)],
-            };
-        }
-        tslib_1.__classPrivateFieldGet(this, _ConfigProvider_recursiveLoadKeyAndDepth, "f").set(key, depth);
-        let config = (_a = tslib_1.__classPrivateFieldGet(this, _ConfigProvider_store, "f").get(key)) !== null && _a !== void 0 ? _a : null;
-        if (!config) {
-            config = await this._load(key, cache);
-        }
-        if (!config) {
-            return { stack, errs: null };
-        }
-        const depKeys = config.extends !== null ? (0, shared_1.toNoEmptyStringArrayFromStringOrArray)(config.extends) : null;
-        if (depKeys) {
-            for (const depKey of depKeys) {
-                const keys = await this._recursiveLoad(depKey, cache, depth + 1);
-                for (const key of keys.stack) {
-                    stack.add(key);
-                }
-                if (keys.errs) {
-                    errs.push(...keys.errs);
-                }
-            }
-        }
-        stack.add(key);
-        return { stack, errs };
-    }
     _validateConfig(config, filePath) {
-        var _a;
         const errors = [];
-        (_a = config.nodeRules) === null || _a === void 0 ? void 0 : _a.forEach(rule => {
-            if (rule.selector) {
-                try {
-                    (0, selector_1.createSelector)(rule.selector);
-                }
-                catch (error) {
-                    if (error instanceof selector_1.InvalidSelectorError) {
-                        errors.push(new parser_utils_1.ConfigParserError(error.message, {
-                            filePath,
-                            raw: rule.selector,
-                        }));
+        if (config.nodeRules)
+            for (const rule of config.nodeRules) {
+                if (rule.selector) {
+                    try {
+                        createSelector(rule.selector);
+                    }
+                    catch (error) {
+                        if (error instanceof InvalidSelectorError) {
+                            errors.push(new ConfigParserError(error.message, {
+                                filePath,
+                                raw: rule.selector,
+                            }));
+                        }
                     }
                 }
             }
-        });
         return errors;
     }
 }
-exports.ConfigProvider = ConfigProvider;
 _ConfigProvider_cache = new WeakMap(), _ConfigProvider_held = new WeakMap(), _ConfigProvider_recursiveLoadKeyAndDepth = new WeakMap(), _ConfigProvider_store = new WeakMap();
-async function load(filePath, cache) {
-    var _a;
-    if (!(0, utils_1.fileExists)(filePath) && moduleExists(filePath)) {
-        const mod = await Promise.resolve(`${filePath}`).then(s => tslib_1.__importStar(require(s)));
-        const config = (_a = mod === null || mod === void 0 ? void 0 : mod.default) !== null && _a !== void 0 ? _a : null;
+async function load(filePath, cache, referrer) {
+    if (!fileExists(filePath) && (await moduleExists(filePath))) {
+        const config = (await generalImport(filePath)) ?? new ConfigLoadError('Module is not found', filePath, referrer);
         return config;
     }
-    const res = await (0, cosmiconfig_1.load)(filePath, !cache);
-    if (!res) {
-        return null;
-    }
-    return res.config;
-}
-function pathResolve(dir, filePath, resolveProps, resolveKey = false) {
-    if (filePath == null) {
-        // @ts-ignore
-        return undefined;
-    }
-    if (typeof filePath === 'string') {
-        // @ts-ignore
-        return resolve(dir, filePath);
-    }
-    if (Array.isArray(filePath)) {
-        // @ts-ignore
-        return filePath.map(fp => pathResolve(dir, fp, resolveProps));
-    }
-    const res = {};
-    for (const [key, fp] of Object.entries(filePath)) {
-        let _key = key;
-        if (resolveKey) {
-            _key = resolve(dir, key);
-        }
-        if (typeof fp === 'string') {
-            if (!resolveProps) {
-                res[_key] = resolve(dir, fp);
-            }
-            else if (resolveProps.includes(key)) {
-                res[_key] = resolve(dir, fp);
-            }
-            else {
-                res[_key] = fp;
-            }
-        }
-        else {
-            res[_key] = fp;
+    const res = await loadConfig(filePath, !cache, referrer).catch((error) => {
+        if (error instanceof ConfigLoadError) {
+            return error;
         }
+        throw error;
+    });
+    if (res instanceof ConfigLoadError) {
+        return res;
     }
-    // @ts-ignore
-    return res;
-}
-function resolve(dir, pathOrModName) {
-    var _a, _b, _c;
-    if (moduleExists(pathOrModName) || isPreset(pathOrModName) || isPlugin(pathOrModName)) {
-        return pathOrModName;
-    }
-    const bangAndPath = (_a = /^(!)(.*)/.exec(pathOrModName)) !== null && _a !== void 0 ? _a : [];
-    const bang = (_b = bangAndPath[1]) !== null && _b !== void 0 ? _b : '';
-    const pathname = (_c = bangAndPath[2]) !== null && _c !== void 0 ? _c : pathOrModName;
-    const absPath = path_1.default.resolve(dir, pathname);
-    return bang + absPath;
-}
-function moduleExists(name) {
-    try {
-        require.resolve(name);
-    }
-    catch (err) {
-        if (
-        // @ts-ignore
-        'code' in err &&
-            // @ts-ignore
-            err.code === 'MODULE_NOT_FOUND') {
-            return false;
-        }
-        throw err;
-    }
-    return true;
-}
-function isPreset(name) {
-    return /^markuplint:/i.test(name);
-}
-function isPlugin(name) {
-    return /^plugin:/i.test(name);
+    return res.config;
 }
 class CircularReferenceError extends ReferenceError {
     constructor() {

package/lib/cosmiconfig.d.ts

@@ -1,17 +1,12 @@
 import type { LoaderSync } from 'cosmiconfig';
+import { ConfigLoadError } from './config-load-error.js';
 type CosmiConfig = ReturnType<LoaderSync>;
-export declare function search<T = CosmiConfig>(
-	dir: string,
-	cacheClear: boolean,
-): Promise<{
-	filePath: string;
-	config: T;
-} | null>;
-export declare function load<T = CosmiConfig>(
-	filePath: string,
-	cacheClear: boolean,
-): Promise<{
-	filePath: string;
-	config: T;
+export declare function search<T = CosmiConfig>(filePath: string, cacheClear: boolean): Promise<{
+    filePath: string;
+    config: T;
 } | null>;
+export declare function load<T = CosmiConfig>(filePath: string, cacheClear: boolean, referrer: string): Promise<ConfigLoadError | {
+    filePath: string;
+    config: T;
+}>;
 export {};