@markuplint/file-resolver 3.0.0-alpha.66 → 3.0.0-dev.176

package/README.md

@@ -1,13 +1,18 @@
 # @markuplint/file-resolver
 
 [![npm version](https://badge.fury.io/js/%40markuplint%2Ffile-resolver.svg)](https://www.npmjs.com/package/@markuplint/file-resolver)
-[![Build Status](https://travis-ci.org/markuplint/markuplint.svg?branch=main)](https://travis-ci.org/markuplint/markuplint)
-[![Coverage Status](https://coveralls.io/repos/github/markuplint/markuplint/badge.svg?branch=main)](https://coveralls.io/github/markuplint/markuplint?branch=main)
 
 ## Install
 
-```sh
+[`markuplint`](https://www.npmjs.com/package/markuplint) package includes this package.
+
+<details>
+<summary>If you are installing purposely, how below:</summary>
+
+```shell
 $ npm install @markuplint/file-resolver
 
 $ yarn add @markuplint/file-resolver
 ```
+
+</details>

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

@@ -40,7 +40,7 @@ async function autoLoadRules(ruleset) {
         }
         let seed = null;
         try {
-            const _module = await Promise.resolve().then(() => __importStar(require(`@markuplint/rule-${ruleName}`)));
+            const _module = await Promise.resolve(`${`@markuplint/rule-${ruleName}`}`).then(s => __importStar(require(s)));
             seed = _module.default;
             if (!(seed && 'defaultValue' in seed && 'defaultOptions' in seed && 'verify' in seed)) {
                 seed = null;
@@ -59,7 +59,7 @@ async function autoLoadRules(ruleset) {
             continue;
         }
         try {
-            const _module = await Promise.resolve().then(() => __importStar(require(`markuplint-rule-${ruleName}`)));
+            const _module = await Promise.resolve(`${`markuplint-rule-${ruleName}`}`).then(s => __importStar(require(s)));
             seed = _module.default;
             if (!(seed && 'defaultValue' in seed && 'defaultOptions' in seed && 'verify' in seed)) {
                 seed = null;

package/lib/config-provider.d.ts

@@ -1,13 +1,14 @@
 import type { MLFile } from './ml-file';
-import type { ConfigSet, Nullable } from './types';
+import type { ConfigSet } from './types';
 import type { Config } from '@markuplint/ml-config';
+import type { Nullable } from '@markuplint/shared';
 export declare class ConfigProvider {
-    #private;
-    set(config: Config, key?: string): string;
-    search(targetFile: MLFile): Promise<string | null>;
-    resolve(targetFile: MLFile, names: Nullable<string>[], cache?: boolean): Promise<ConfigSet>;
-    private _mergeConfigs;
-    private _recursiveLoad;
-    private _load;
-    private _pathResolve;
+	#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;
 }

package/lib/config-provider.js

@@ -1,48 +1,31 @@
 "use strict";
-var _ConfigProvider_store, _ConfigProvider_cache, _ConfigProvider_held, _ConfigProvider_recursiveLoadKeyAndDepth;
+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 shared_1 = require("@markuplint/shared");
 const cosmiconfig_1 = require("./cosmiconfig");
 const resolve_plugins_1 = require("./resolve-plugins");
 const utils_1 = require("./utils");
 const KEY_SEPARATOR = '__ML_CONFIG_MERGE__';
 class ConfigProvider {
     constructor() {
-        _ConfigProvider_store.set(this, new Map());
         _ConfigProvider_cache.set(this, new Map());
         _ConfigProvider_held.set(this, new Set());
         _ConfigProvider_recursiveLoadKeyAndDepth.set(this, new Map());
-    }
-    set(config, key) {
-        key = key || (0, utils_1.uuid)();
-        tslib_1.__classPrivateFieldGet(this, _ConfigProvider_store, "f").set(key, config);
-        return key;
-    }
-    async search(targetFile) {
-        if (!(await targetFile.dirExists())) {
-            return null;
-        }
-        const res = await (0, cosmiconfig_1.search)(targetFile.path, false);
-        if (!res) {
-            return null;
-        }
-        const { filePath, config } = res;
-        const pathResolvedConfig = this._pathResolve(config, filePath);
-        tslib_1.__classPrivateFieldGet(this, _ConfigProvider_store, "f").set(filePath, pathResolvedConfig);
-        return filePath;
+        _ConfigProvider_store.set(this, new Map());
     }
     async resolve(targetFile, names, cache = true) {
-        var _a;
+        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)();
         }
-        const keys = names.filter(utils_1.nonNullableFilter);
+        const keys = names.filter(shared_1.nonNullableFilter);
         const key = keys.join(KEY_SEPARATOR);
         const currentConfig = tslib_1.__classPrivateFieldGet(this, _ConfigProvider_cache, "f").get(key);
         if (currentConfig) {
@@ -50,21 +33,14 @@ class ConfigProvider {
         }
         let configSet = await this._mergeConfigs(keys, cache);
         const plugins = await (0, resolve_plugins_1.resolvePlugins)(configSet.config.plugins);
-        if (tslib_1.__classPrivateFieldGet(this, _ConfigProvider_held, "f").size) {
+        if (tslib_1.__classPrivateFieldGet(this, _ConfigProvider_held, "f").size > 0) {
             const extendHelds = Array.from(tslib_1.__classPrivateFieldGet(this, _ConfigProvider_held, "f").values());
             for (const held of extendHelds) {
-                const [, prefix, namespace, name] = held.match(/^([a-z]+:)([^/]+)(?:\/(.+))?$/) || [];
+                const [, prefix, namespace, name] = (_a = held.match(/^([a-z]+:)([^/]+)(?:\/(.+))?$/)) !== null && _a !== void 0 ? _a : [];
                 switch (prefix) {
                     case 'plugin:': {
                         const plugin = plugins.find(plugin => plugin.name === namespace);
-                        const config = (_a = plugin === null || plugin === void 0 ? void 0 : plugin.configs) === null || _a === void 0 ? void 0 : _a[name];
-                        if (config) {
-                            this.set(config, held);
-                        }
-                        break;
-                    }
-                    case 'markuplint:': {
-                        const config = await (0, ml_core_1.getPreset)(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 : ''];
                         if (config) {
                             this.set(config, held);
                         }
@@ -81,9 +57,10 @@ class ConfigProvider {
             const globs = Object.keys(overrides);
             for (const glob of globs) {
                 const isMatched = targetFile.matches(glob);
-                if (isMatched) {
+                const config = overrides[glob];
+                if (isMatched && config) {
                     // Note: Original config disappears
-                    configSet.config = overrides[glob];
+                    configSet.config = config;
                 }
             }
         }
@@ -94,6 +71,52 @@ class ConfigProvider {
         tslib_1.__classPrivateFieldGet(this, _ConfigProvider_cache, "f").set(key, result);
         return result;
     }
+    async search(targetFile) {
+        if (!(await targetFile.dirExists())) {
+            return null;
+        }
+        const res = await (0, cosmiconfig_1.search)(targetFile.path, false);
+        if (!res) {
+            return null;
+        }
+        const { filePath, config } = res;
+        const pathResolvedConfig = this._pathResolve(config, filePath);
+        tslib_1.__classPrivateFieldGet(this, _ConfigProvider_store, "f").set(filePath, pathResolvedConfig);
+        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);
+        return key;
+    }
+    async _load(filePath, cache) {
+        var _a;
+        const entity = tslib_1.__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);
+            return pathResolvedConfig;
+        }
+        if (isPlugin(filePath)) {
+            tslib_1.__classPrivateFieldGet(this, _ConfigProvider_held, "f").add(filePath);
+            return null;
+        }
+        if (!moduleExists(filePath) && !path_1.default.isAbsolute(filePath)) {
+            throw new TypeError(`${filePath} is not an absolute path`);
+        }
+        const config = await load(filePath, cache);
+        if (!config) {
+            return null;
+        }
+        const pathResolvedConfig = this._pathResolve(config, filePath);
+        tslib_1.__classPrivateFieldGet(this, _ConfigProvider_store, "f").set(filePath, pathResolvedConfig);
+        return pathResolvedConfig;
+    }
     async _mergeConfigs(keys, cache) {
         const resolvedKeys = new Set();
         const errs = [];
@@ -109,7 +132,7 @@ class ConfigProvider {
         }
         const configs = Array.from(resolvedKeys)
             .map(name => tslib_1.__classPrivateFieldGet(this, _ConfigProvider_store, "f").get(name))
-            .filter(utils_1.nonNullableFilter);
+            .filter(shared_1.nonNullableFilter);
         let resultConfig = {};
         for (const config of configs) {
             resultConfig = (0, ml_config_1.mergeConfig)(resultConfig, config);
@@ -120,7 +143,20 @@ class ConfigProvider {
             errs,
         };
     }
+    _pathResolve(config, filePath) {
+        const dir = path_1.default.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),
+        };
+    }
     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);
@@ -131,14 +167,14 @@ class ConfigProvider {
             };
         }
         tslib_1.__classPrivateFieldGet(this, _ConfigProvider_recursiveLoadKeyAndDepth, "f").set(key, depth);
-        let config = tslib_1.__classPrivateFieldGet(this, _ConfigProvider_store, "f").get(key) || null;
+        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 ? (Array.isArray(config.extends) ? config.extends : [config.extends]) : 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);
@@ -153,45 +189,14 @@ class ConfigProvider {
         stack.add(key);
         return { stack, errs };
     }
-    async _load(filePath, cache) {
-        const entity = tslib_1.__classPrivateFieldGet(this, _ConfigProvider_store, "f").get(filePath);
-        if (entity) {
-            return entity;
-        }
-        if (isPrefixedName(filePath)) {
-            tslib_1.__classPrivateFieldGet(this, _ConfigProvider_held, "f").add(filePath);
-            return null;
-        }
-        if (!moduleExists(filePath) && !path_1.default.isAbsolute(filePath)) {
-            throw new TypeError(`${filePath} is not an absolute path`);
-        }
-        const config = await load(filePath, cache);
-        if (!config) {
-            return null;
-        }
-        const pathResolvedConfig = this._pathResolve(config, filePath);
-        tslib_1.__classPrivateFieldGet(this, _ConfigProvider_store, "f").set(filePath, pathResolvedConfig);
-        return pathResolvedConfig;
-    }
-    _pathResolve(config, filePath) {
-        const dir = path_1.default.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),
-        };
-    }
 }
 exports.ConfigProvider = ConfigProvider;
-_ConfigProvider_store = new WeakMap(), _ConfigProvider_cache = new WeakMap(), _ConfigProvider_held = new WeakMap(), _ConfigProvider_recursiveLoadKeyAndDepth = new WeakMap();
+_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().then(() => tslib_1.__importStar(require(filePath)));
-        const config = (mod === null || mod === void 0 ? void 0 : mod.default) || null;
+        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;
         return config;
     }
     const res = await (0, cosmiconfig_1.load)(filePath, !cache);
@@ -238,10 +243,7 @@ function pathResolve(dir, filePath, resolveProps, resolveKey = false) {
     return res;
 }
 function resolve(dir, pathOrModName) {
-    if (isPrefixedName(pathOrModName)) {
-        return pathOrModName;
-    }
-    if (moduleExists(pathOrModName)) {
+    if (moduleExists(pathOrModName) || isPreset(pathOrModName) || isPlugin(pathOrModName)) {
         return pathOrModName;
     }
     return path_1.default.resolve(dir, pathOrModName);
@@ -262,8 +264,11 @@ function moduleExists(name) {
     }
     return true;
 }
-function isPrefixedName(name) {
-    return /^(?:markuplint|plugin):/.test(name);
+function isPreset(name) {
+    return /^markuplint:/i.test(name);
+}
+function isPlugin(name) {
+    return /^plugin:/i.test(name);
 }
 class CircularReferenceError extends ReferenceError {
     constructor() {

package/lib/cosmiconfig.d.ts

@@ -1,11 +1,17 @@
 import type { LoaderSync } from 'cosmiconfig';
-declare type CosmiConfig = ReturnType<LoaderSync>;
-export declare function search<T = CosmiConfig>(dir: string, cacheClear: boolean): Promise<{
-    filePath: string;
-    config: T;
+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 load<T = CosmiConfig>(
+	filePath: string,
+	cacheClear: boolean,
+): Promise<{
+	filePath: string;
+	config: T;
 } | null>;
 export {};

package/lib/cosmiconfig.js

@@ -4,9 +4,11 @@ exports.load = exports.search = void 0;
 const tslib_1 = require("tslib");
 const path_1 = tslib_1.__importDefault(require("path"));
 const cosmiconfig_1 = require("cosmiconfig");
+const cosmiconfig_typescript_loader_1 = require("cosmiconfig-typescript-loader");
 const jsonc_1 = require("jsonc");
 const explorer = (0, cosmiconfig_1.cosmiconfig)('markuplint', {
     loaders: {
+        '.ts': (0, cosmiconfig_typescript_loader_1.TypeScriptLoader)(),
         noExt: ((path, content) => {
             try {
                 return jsonc_1.jsonc.parse(content);

package/lib/ml-file/get-files.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFiles = void 0;
-const tslib_1 = require("tslib");
-const glob_1 = tslib_1.__importDefault(require("glob"));
+const glob_1 = require("glob");
 const get_file_1 = require("./get-file");
 /**
  * Get files
@@ -12,14 +11,7 @@ const get_file_1 = require("./get-file");
  * @param filePathOrGlob
  */
 async function getFiles(filePathOrGlob) {
-    const fileList = await new Promise((resolve, reject) => {
-        (0, glob_1.default)(filePathOrGlob, {}, (err, matches) => {
-            if (err) {
-                reject(err);
-            }
-            resolve(matches);
-        });
-    }).catch(() => []);
+    const fileList = await (0, glob_1.glob)(filePathOrGlob, {}).catch(() => []);
     return fileList.map(fileName => (0, get_file_1.getFile)(fileName));
 }
 exports.getFiles = getFiles;

package/lib/ml-file/ml-file.d.ts

@@ -1,23 +1,23 @@
 import type { Target } from '../types';
 export declare class MLFile {
-    #private;
-    constructor(target: Target);
-    get path(): string;
-    /**
-     * Normalized `MLFile.path`
-     */
-    get nPath(): string;
-    get dirname(): string;
-    /**
-     * Normalized `MLFile.dirname`
-     */
-    get nDirname(): string;
-    isFile(): Promise<boolean>;
-    isExist(): Promise<boolean>;
-    dirExists(): Promise<boolean>;
-    getCode(): Promise<string>;
-    setCode(code: string): void;
-    matches(globPath: string): boolean;
-    private _fetch;
-    private _stat;
+	#private;
+	constructor(target: Target);
+	get dirname(): string;
+	/**
+	 * Normalized `MLFile.dirname`
+	 */
+	get nDirname(): string;
+	/**
+	 * Normalized `MLFile.path`
+	 */
+	get nPath(): string;
+	get path(): string;
+	dirExists(): Promise<boolean>;
+	getCode(): Promise<string>;
+	isExist(): Promise<boolean>;
+	isFile(): Promise<boolean>;
+	matches(globPath: string): boolean;
+	setCode(code: string): void;
+	private _fetch;
+	private _stat;
 }

package/lib/ml-file/ml-file.js

@@ -1,23 +1,24 @@
 "use strict";
-var _MLFile_type, _MLFile_basename, _MLFile_dirname, _MLFile_code, _MLFile_stat;
+var _MLFile_basename, _MLFile_code, _MLFile_dirname, _MLFile_stat, _MLFile_type;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MLFile = void 0;
 const tslib_1 = require("tslib");
 const fs_1 = require("fs");
 const path_1 = tslib_1.__importDefault(require("path"));
-const minimatch_1 = tslib_1.__importDefault(require("minimatch"));
+const minimatch_1 = require("minimatch");
 class MLFile {
     constructor(target) {
-        _MLFile_type.set(this, void 0);
+        var _a, _b;
         _MLFile_basename.set(this, void 0);
-        _MLFile_dirname.set(this, void 0);
         _MLFile_code.set(this, void 0);
+        _MLFile_dirname.set(this, void 0);
         /**
          * - `Stats`: Exists
          * - `null`: Not exists
          * - `undefined`: Doesn't read yet
          */
         _MLFile_stat.set(this, undefined);
+        _MLFile_type.set(this, void 0);
         if (typeof target === 'string') {
             tslib_1.__classPrivateFieldSet(this, _MLFile_basename, path_1.default.basename(target), "f");
             tslib_1.__classPrivateFieldSet(this, _MLFile_dirname, path_1.default.dirname(target), "f");
@@ -30,21 +31,12 @@ class MLFile {
             tslib_1.__classPrivateFieldSet(this, _MLFile_dirname, path_1.default.dirname(target.name), "f");
         }
         else {
-            tslib_1.__classPrivateFieldSet(this, _MLFile_basename, target.name || '<AnonymousFile>', "f");
-            tslib_1.__classPrivateFieldSet(this, _MLFile_dirname, target.workspace || process.cwd(), "f");
+            tslib_1.__classPrivateFieldSet(this, _MLFile_basename, (_a = target.name) !== null && _a !== void 0 ? _a : '<AnonymousFile>', "f");
+            tslib_1.__classPrivateFieldSet(this, _MLFile_dirname, (_b = target.workspace) !== null && _b !== void 0 ? _b : process.cwd(), "f");
         }
         tslib_1.__classPrivateFieldSet(this, _MLFile_code, target.sourceCode, "f");
         tslib_1.__classPrivateFieldSet(this, _MLFile_type, 'code-base', "f");
     }
-    get path() {
-        return path_1.default.resolve(tslib_1.__classPrivateFieldGet(this, _MLFile_dirname, "f"), tslib_1.__classPrivateFieldGet(this, _MLFile_basename, "f"));
-    }
-    /**
-     * Normalized `MLFile.path`
-     */
-    get nPath() {
-        return pathNormalize(this.path);
-    }
     get dirname() {
         return tslib_1.__classPrivateFieldGet(this, _MLFile_dirname, "f");
     }
@@ -54,19 +46,14 @@ class MLFile {
     get nDirname() {
         return pathNormalize(this.dirname);
     }
-    async isFile() {
-        if (tslib_1.__classPrivateFieldGet(this, _MLFile_type, "f") === 'code-base') {
-            return true;
-        }
-        const stat = await this._stat();
-        return !!stat && stat.isFile();
+    /**
+     * Normalized `MLFile.path`
+     */
+    get nPath() {
+        return pathNormalize(this.path);
     }
-    async isExist() {
-        if (tslib_1.__classPrivateFieldGet(this, _MLFile_type, "f") === 'code-base') {
-            return true;
-        }
-        const stat = await this._stat();
-        return !!stat;
+    get path() {
+        return path_1.default.resolve(tslib_1.__classPrivateFieldGet(this, _MLFile_dirname, "f"), tslib_1.__classPrivateFieldGet(this, _MLFile_basename, "f"));
     }
     async dirExists() {
         return !!(await stat(tslib_1.__classPrivateFieldGet(this, _MLFile_dirname, "f")));
@@ -80,15 +67,29 @@ class MLFile {
         }
         return '';
     }
+    async isExist() {
+        if (tslib_1.__classPrivateFieldGet(this, _MLFile_type, "f") === 'code-base') {
+            return true;
+        }
+        const stat = await this._stat();
+        return !!stat;
+    }
+    async isFile() {
+        if (tslib_1.__classPrivateFieldGet(this, _MLFile_type, "f") === 'code-base') {
+            return true;
+        }
+        const stat = await this._stat();
+        return !!stat && stat.isFile();
+    }
+    matches(globPath) {
+        return (0, minimatch_1.minimatch)(this.nPath, pathNormalize(globPath));
+    }
     setCode(code) {
         if (tslib_1.__classPrivateFieldGet(this, _MLFile_type, "f") === 'file-base') {
             throw new Error(`This file object is readonly (File-base: ${this.path})`);
         }
         tslib_1.__classPrivateFieldSet(this, _MLFile_code, code, "f");
     }
-    matches(globPath) {
-        return (0, minimatch_1.default)(this.nPath, pathNormalize(globPath));
-    }
     async _fetch() {
         const code = await fs_1.promises.readFile(this.path, { encoding: 'utf-8' });
         tslib_1.__classPrivateFieldSet(this, _MLFile_code, code, "f");
@@ -103,7 +104,7 @@ class MLFile {
     }
 }
 exports.MLFile = MLFile;
-_MLFile_type = new WeakMap(), _MLFile_basename = new WeakMap(), _MLFile_dirname = new WeakMap(), _MLFile_code = new WeakMap(), _MLFile_stat = new WeakMap();
+_MLFile_basename = new WeakMap(), _MLFile_code = new WeakMap(), _MLFile_dirname = new WeakMap(), _MLFile_stat = new WeakMap(), _MLFile_type = new WeakMap();
 async function stat(filePath) {
     try {
         return await fs_1.promises.stat(filePath);

package/lib/resolve-files.d.ts

@@ -1,3 +1,3 @@
 import type { MLFile } from './ml-file';
 import type { Target } from './types';
-export declare function resolveFiles(targetList: Target[]): Promise<MLFile[]>;
+export declare function resolveFiles(targetList: readonly Readonly<Target>[]): Promise<MLFile[]>;

package/lib/resolve-parser.d.ts

@@ -1,9 +1,13 @@
 import type { MLFile } from './ml-file';
-import type { MLMarkupLanguageParser } from '@markuplint/ml-ast';
-import type { ParserConfig, ParserOptions } from '@markuplint/ml-config';
-export declare function resolveParser(file: MLFile, parserConfig?: ParserConfig, parserOptions?: ParserOptions): Promise<{
-    parserModName: string;
-    parser: MLMarkupLanguageParser;
-    parserOptions: ParserOptions;
-    matched: boolean;
+import type { MLMarkupLanguageParser, ParserOptions } from '@markuplint/ml-ast';
+import type { ParserConfig } from '@markuplint/ml-config';
+export declare function resolveParser(
+	file: Readonly<MLFile>,
+	parserConfig?: ParserConfig,
+	parserOptions?: ParserOptions,
+): Promise<{
+	parserModName: string;
+	parser: MLMarkupLanguageParser;
+	parserOptions: ParserOptions;
+	matched: boolean;
 }>;

package/lib/resolve-parser.js

@@ -10,16 +10,18 @@ async function resolveParser(file, parserConfig, parserOptions) {
         ...parserConfig,
         '/\\.html?$/i': '@markuplint/html-parser',
     };
-    parserOptions = parserOptions || {};
+    parserOptions = parserOptions !== null && parserOptions !== void 0 ? parserOptions : {};
     let parserModName = '@markuplint/html-parser';
     let matched = false;
-    if (parserConfig) {
-        for (const pattern of Object.keys(parserConfig)) {
-            if (path_1.default.basename(file.path).match((0, utils_1.toRegxp)(pattern))) {
-                parserModName = parserConfig[pattern];
-                matched = true;
-                break;
+    for (const pattern of Object.keys(parserConfig)) {
+        if (path_1.default.basename(file.path).match((0, utils_1.toRegexp)(pattern))) {
+            const modName = parserConfig[pattern];
+            if (!modName) {
+                continue;
             }
+            parserModName = modName;
+            matched = true;
+            break;
         }
     }
     const parser = await importParser(parserModName);
@@ -36,6 +38,6 @@ async function importParser(parserModName) {
     if (entity) {
         return entity;
     }
-    const parser = await Promise.resolve().then(() => tslib_1.__importStar(require(parserModName)));
+    const parser = await Promise.resolve(`${parserModName}`).then(s => tslib_1.__importStar(require(s)));
     return parser;
 }

package/lib/resolve-plugins.d.ts

@@ -1,4 +1,4 @@
 import type { PluginConfig } from '@markuplint/ml-config';
 import type { Plugin } from '@markuplint/ml-core';
-export declare function resolvePlugins(pluginPaths?: (string | PluginConfig)[]): Promise<Plugin[]>;
+export declare function resolvePlugins(pluginPaths?: readonly (string | PluginConfig)[]): Promise<Plugin[]>;
 export declare function cacheClear(): void;