@markuplint/file-resolver 3.13.0 → 4.0.0-alpha.2

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,7 +14,7 @@ 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;
@@ -50,7 +24,7 @@ async function autoLoadRules(ruleset) {
             errors.push(e);
         }
         if (seed) {
-            const rule = new ml_core_1.MLRule({
+            const rule = new MLRule({
                 name: ruleName,
                 ...seed,
             });
@@ -59,7 +33,7 @@ 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;
@@ -69,7 +43,7 @@ async function autoLoadRules(ruleset) {
             errors.push(e);
         }
         if (seed) {
-            const rule = new ml_core_1.MLRule({
+            const rule = new MLRule({
                 name: ruleName,
                 ...seed,
             });
@@ -85,4 +59,3 @@ async function autoLoadRules(ruleset) {
         errors: errors.slice(),
     };
 }
-exports.autoLoadRules = autoLoadRules;

package/lib/config-provider.d.ts

@@ -1,5 +1,5 @@
-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 {

package/lib/config-provider.js

@@ -1,19 +1,18 @@
-"use strict";
 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 { __classPrivateFieldGet } from "tslib";
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { mergeConfig } from '@markuplint/ml-config';
+import { getPreset } from '@markuplint/ml-core';
+import { ConfigParserError } from '@markuplint/parser-utils';
+import { InvalidSelectorError, createSelector } from '@markuplint/selector';
+import { nonNullableFilter, toNoEmptyStringArrayFromStringOrArray } from '@markuplint/shared';
+import { load as loadConfig, search } from './cosmiconfig.js';
+import { cacheClear, resolvePlugins } from './resolve-plugins.js';
+import { fileExists, uuid } from './utils.js';
+const require = createRequire(import.meta.url);
 const KEY_SEPARATOR = '__ML_CONFIG_MERGE__';
-class ConfigProvider {
+export class ConfigProvider {
     constructor() {
         _ConfigProvider_cache.set(this, new Map());
         _ConfigProvider_held.set(this, new Set());
@@ -21,36 +20,35 @@ class ConfigProvider {
         _ConfigProvider_store.set(this, new Map());
     }
     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];
         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 = Array.from(__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);
                         }
@@ -59,7 +57,7 @@ class ConfigProvider {
                 }
             }
             configSet = await this._mergeConfigs([...keys, ...extendHelds], cache);
-            tslib_1.__classPrivateFieldGet(this, _ConfigProvider_held, "f").clear();
+            __classPrivateFieldGet(this, _ConfigProvider_held, "f").clear();
         }
         // Resolves `overrides`
         if (configSet.config.overrides) {
@@ -78,60 +76,59 @@ 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())) {
             return null;
         }
-        const res = await (0, cosmiconfig_1.search)(targetFile.path, false);
+        const res = await 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);
+        const pathResolvedConfig = await this._pathResolve(config, filePath);
+        __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);
+        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);
+        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);
+            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);
+            __classPrivateFieldGet(this, _ConfigProvider_held, "f").add(filePath);
             return null;
         }
-        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 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) {
         const resolvedKeys = new Set();
         const errs = [];
         for (const key of keys) {
-            tslib_1.__classPrivateFieldGet(this, _ConfigProvider_recursiveLoadKeyAndDepth, "f").clear();
+            __classPrivateFieldGet(this, _ConfigProvider_recursiveLoadKeyAndDepth, "f").clear();
             const keySet = await this._recursiveLoad(key, cache);
             for (const k of keySet.stack) {
                 resolvedKeys.add(k);
@@ -141,11 +138,11 @@ class ConfigProvider {
             }
         }
         const configs = Array.from(resolvedKeys)
-            .map(name => tslib_1.__classPrivateFieldGet(this, _ConfigProvider_store, "f").get(name))
-            .filter(shared_1.nonNullableFilter);
+            .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);
+            resultConfig = mergeConfig(resultConfig, config);
         }
         return {
             config: resultConfig,
@@ -153,38 +150,37 @@ 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 pathResolve(dir, config.extends),
+            plugins: await pathResolve(dir, config.plugins, ['name']),
+            parser: await pathResolve(dir, config.parser),
+            specs: await pathResolve(dir, config.specs),
+            excludeFiles: await pathResolve(dir, config.excludeFiles),
+            overrides: await 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);
+        const ancestorDepth = __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;
+        __classPrivateFieldGet(this, _ConfigProvider_recursiveLoadKeyAndDepth, "f").set(key, depth);
+        let config = __classPrivateFieldGet(this, _ConfigProvider_store, "f").get(key) ?? 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;
+        const depKeys = config.extends !== null ? toNoEmptyStringArrayFromStringOrArray(config.extends) : null;
         if (depKeys) {
             for (const depKey of depKeys) {
                 const keys = await this._recursiveLoad(depKey, cache, depth + 1);
@@ -200,16 +196,15 @@ class ConfigProvider {
         return { stack, errs };
     }
     _validateConfig(config, filePath) {
-        var _a;
         const errors = [];
-        (_a = config.nodeRules) === null || _a === void 0 ? void 0 : _a.forEach(rule => {
+        config.nodeRules?.forEach(rule => {
             if (rule.selector) {
                 try {
-                    (0, selector_1.createSelector)(rule.selector);
+                    createSelector(rule.selector);
                 }
                 catch (error) {
-                    if (error instanceof selector_1.InvalidSelectorError) {
-                        errors.push(new parser_utils_1.ConfigParserError(error.message, {
+                    if (error instanceof InvalidSelectorError) {
+                        errors.push(new ConfigParserError(error.message, {
                             filePath,
                             raw: rule.selector,
                         }));
@@ -220,22 +215,20 @@ class ConfigProvider {
         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;
+    if (!fileExists(filePath) && (await moduleExists(filePath))) {
+        const mod = await import(filePath);
+        const config = mod?.default ?? null;
         return config;
     }
-    const res = await (0, cosmiconfig_1.load)(filePath, !cache);
+    const res = await loadConfig(filePath, !cache);
     if (!res) {
         return null;
     }
     return res.config;
 }
-function pathResolve(dir, filePath, resolveProps, resolveKey = false) {
+async function pathResolve(dir, filePath, resolveProps, resolveKey = false) {
     if (filePath == null) {
         // @ts-ignore
         return undefined;
@@ -246,20 +239,20 @@ function pathResolve(dir, filePath, resolveProps, resolveKey = false) {
     }
     if (Array.isArray(filePath)) {
         // @ts-ignore
-        return filePath.map(fp => pathResolve(dir, fp, resolveProps));
+        return Promise.all(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);
+            _key = await resolve(dir, key);
         }
         if (typeof fp === 'string') {
             if (!resolveProps) {
-                res[_key] = resolve(dir, fp);
+                res[_key] = await resolve(dir, fp);
             }
             else if (resolveProps.includes(key)) {
-                res[_key] = resolve(dir, fp);
+                res[_key] = await resolve(dir, fp);
             }
             else {
                 res[_key] = fp;
@@ -272,30 +265,48 @@ function pathResolve(dir, filePath, resolveProps, resolveKey = false) {
     // @ts-ignore
     return res;
 }
-function resolve(dir, pathOrModName) {
-    var _a, _b, _c;
-    if (moduleExists(pathOrModName) || isPreset(pathOrModName) || isPlugin(pathOrModName)) {
+async function resolve(dir, pathOrModName) {
+    if ((await 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);
+    const bangAndPath = /^(!)(.*)/.exec(pathOrModName) ?? [];
+    const bang = bangAndPath[1] ?? '';
+    const pathname = bangAndPath[2] ?? pathOrModName;
+    const absPath = path.resolve(dir, pathname);
     return bang + absPath;
 }
-function moduleExists(name) {
+async function moduleExists(name) {
     try {
-        require.resolve(name);
+        await import(name);
     }
     catch (err) {
-        if (
-        // @ts-ignore
-        'code' in err &&
+        if (err instanceof Error) {
+            if (/^Parse failure/i.test(err.message)) {
+                return true;
+            }
+        }
+        try {
+            require.resolve(name);
+        }
+        catch (err) {
+            if (
             // @ts-ignore
-            err.code === 'MODULE_NOT_FOUND') {
-            return false;
+            'code' in err &&
+                // @ts-ignore
+                err.code === 'ERR_PACKAGE_PATH_NOT_EXPORTED') {
+                // Even if there are issues with the fields,
+                // assume that the module exists and return true.
+                return true;
+            }
+            if (
+            // @ts-ignore
+            'code' in err &&
+                // @ts-ignore
+                err.code === 'MODULE_NOT_FOUND') {
+                return false;
+            }
+            throw err;
         }
-        throw err;
     }
     return true;
 }

package/lib/cosmiconfig.js

@@ -1,33 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.load = exports.search = void 0;
-const tslib_1 = require("tslib");
-const path_1 = tslib_1.__importDefault(require("path"));
-const parser_utils_1 = require("@markuplint/parser-utils");
-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', {
+import path from 'node:path';
+import { ConfigParserError } from '@markuplint/parser-utils';
+import { cosmiconfig, defaultLoaders } from 'cosmiconfig';
+import { jsonc } from 'jsonc';
+const explorer = cosmiconfig('markuplint', {
     loaders: {
-        '.ts': (0, cosmiconfig_typescript_loader_1.TypeScriptLoader)(),
         noExt: ((path, content) => {
             try {
-                return jsonc_1.jsonc.parse(content);
+                return jsonc.parse(content);
             }
             catch (error) {
                 if (error instanceof Error && error.name === 'JSONError') {
-                    return cosmiconfig_1.defaultLoaders['noExt'](path, content);
+                    return defaultLoaders['noExt'](path, content);
                 }
                 throw error;
             }
         }),
     },
 });
-async function search(dir, cacheClear) {
+export async function search(dir, cacheClear) {
     if (cacheClear) {
         explorer.clearCaches();
     }
-    dir = path_1.default.dirname(dir);
+    dir = path.dirname(dir);
     const result = await explorer.search(dir).catch(cacheConfigError(dir));
     if (!result || result.isEmpty) {
         return null;
@@ -37,8 +31,7 @@ async function search(dir, cacheClear) {
         config: result.config,
     };
 }
-exports.search = search;
-async function load(filePath, cacheClear) {
+export async function load(filePath, cacheClear) {
     if (cacheClear) {
         explorer.clearCaches();
     }
@@ -51,7 +44,6 @@ async function load(filePath, cacheClear) {
         config: result.config,
     };
 }
-exports.load = load;
 class ConfigLoadError extends Error {
     constructor(message, filePath) {
         super(message + ` in ${filePath}`);
@@ -60,13 +52,12 @@ class ConfigLoadError extends Error {
 }
 function cacheConfigError(fileOrDirPath) {
     return (reason) => {
-        var _a;
         if (reason instanceof Error) {
             switch (reason.name) {
                 case 'YAMLException':
-                    throw new parser_utils_1.ConfigParserError(reason.message, {
+                    throw new ConfigParserError(reason.message, {
                         // @ts-ignore
-                        filePath: (_a = reason.filepath) !== null && _a !== void 0 ? _a : fileOrDirPath,
+                        filePath: reason.filepath ?? fileOrDirPath,
                     });
             }
             throw new ConfigLoadError(reason.message, fileOrDirPath);

package/lib/index.d.ts

@@ -1,7 +1,7 @@
-export type { MLFile } from './ml-file';
-export * from './config-provider';
-export * from './resolve-files';
-export * from './resolve-parser';
-export * from './resolve-rules';
-export * from './resolve-specs';
-export * from './types';
+export type { MLFile } from './ml-file/index.js';
+export * from './config-provider.js';
+export * from './resolve-files.js';
+export * from './resolve-parser.js';
+export * from './resolve-rules.js';
+export * from './resolve-specs.js';
+export * from './types.js';

package/lib/index.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./config-provider"), exports);
-tslib_1.__exportStar(require("./resolve-files"), exports);
-tslib_1.__exportStar(require("./resolve-parser"), exports);
-tslib_1.__exportStar(require("./resolve-rules"), exports);
-tslib_1.__exportStar(require("./resolve-specs"), exports);
-tslib_1.__exportStar(require("./types"), exports);
+export * from './config-provider.js';
+export * from './resolve-files.js';
+export * from './resolve-parser.js';
+export * from './resolve-rules.js';
+export * from './resolve-specs.js';
+export * from './types.js';

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

@@ -1,2 +1,2 @@
-import { MLFile } from './ml-file';
+import { MLFile } from './ml-file.js';
 export declare function getAnonymousFile(context: string, workspace?: string, name?: string): MLFile;

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

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAnonymousFile = void 0;
-const ml_file_1 = require("./ml-file");
-function getAnonymousFile(context, workspace, name) {
-    const file = new ml_file_1.MLFile({
+import { MLFile } from './ml-file.js';
+export function getAnonymousFile(context, workspace, name) {
+    const file = new MLFile({
         sourceCode: context,
         workspace,
         name,
     });
     return file;
 }
-exports.getAnonymousFile = getAnonymousFile;

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

@@ -1,2 +1,2 @@
-import { MLFile } from './ml-file';
+import { MLFile } from './ml-file.js';
 export declare function getFile(filePath: string): MLFile;

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

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFile = void 0;
-const ml_file_1 = require("./ml-file");
-function getFile(filePath) {
-    const file = new ml_file_1.MLFile(filePath);
+import { MLFile } from './ml-file.js';
+export function getFile(filePath) {
+    const file = new MLFile(filePath);
     return file;
 }
-exports.getFile = getFile;

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

@@ -1,4 +1,4 @@
-import type { MLFile } from './ml-file';
+import type { MLFile } from './ml-file.js';
 /**
  * Get files
  *

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

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFiles = void 0;
-const glob_1 = require("glob");
-const get_file_1 = require("./get-file");
+import { glob } from 'glob';
+import { getFile } from './get-file.js';
 /**
  * Get files
  *
@@ -10,8 +7,7 @@ const get_file_1 = require("./get-file");
  *
  * @param filePathOrGlob
  */
-async function getFiles(filePathOrGlob) {
-    const fileList = await (0, glob_1.glob)(filePathOrGlob, {}).catch(() => []);
-    return fileList.map(fileName => (0, get_file_1.getFile)(fileName));
+export async function getFiles(filePathOrGlob) {
+    const fileList = await glob(filePathOrGlob, {}).catch(() => []);
+    return fileList.map(fileName => getFile(fileName));
 }
-exports.getFiles = getFiles;

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

@@ -1,4 +1,4 @@
-export type { MLFile } from './ml-file';
-export * from './get-anonymous-file';
-export * from './get-file';
-export * from './get-files';
+export type { MLFile } from './ml-file.js';
+export * from './get-anonymous-file.js';
+export * from './get-file.js';
+export * from './get-files.js';

package/lib/ml-file/index.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./get-anonymous-file"), exports);
-tslib_1.__exportStar(require("./get-file"), exports);
-tslib_1.__exportStar(require("./get-files"), exports);
+export * from './get-anonymous-file.js';
+export * from './get-file.js';
+export * from './get-files.js';

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

@@ -1,4 +1,4 @@
-import type { Target } from '../types';
+import type { Target } from '../types.js';
 export declare class MLFile {
     #private;
     constructor(target: Target);
@@ -14,7 +14,7 @@ export declare class MLFile {
     get path(): string;
     dirExists(): Promise<boolean>;
     getCode(): Promise<string>;
-    ignored(globPath: string | readonly string[]): boolean;
+    ignored(globPath: string | readonly string[]): any;
     isExist(): Promise<boolean>;
     isFile(): Promise<boolean>;
     matches(globPath: string): boolean;

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

@@ -1,15 +1,11 @@
-"use strict";
 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 ignore_1 = tslib_1.__importDefault(require("ignore"));
-const minimatch_1 = require("minimatch");
-class MLFile {
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import ignore from 'ignore';
+import { minimatch } from 'minimatch';
+export class MLFile {
     constructor(target) {
-        var _a, _b;
         _MLFile_basename.set(this, void 0);
         _MLFile_code.set(this, void 0);
         _MLFile_dirname.set(this, void 0);
@@ -21,25 +17,25 @@ class MLFile {
         _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");
-            tslib_1.__classPrivateFieldSet(this, _MLFile_code, null, "f");
-            tslib_1.__classPrivateFieldSet(this, _MLFile_type, 'file-base', "f");
+            __classPrivateFieldSet(this, _MLFile_basename, path.basename(target), "f");
+            __classPrivateFieldSet(this, _MLFile_dirname, path.dirname(target), "f");
+            __classPrivateFieldSet(this, _MLFile_code, null, "f");
+            __classPrivateFieldSet(this, _MLFile_type, 'file-base', "f");
             return;
         }
-        if (!target.workspace && target.name && path_1.default.isAbsolute(target.name)) {
-            tslib_1.__classPrivateFieldSet(this, _MLFile_basename, path_1.default.basename(target.name), "f");
-            tslib_1.__classPrivateFieldSet(this, _MLFile_dirname, path_1.default.dirname(target.name), "f");
+        if (!target.workspace && target.name && path.isAbsolute(target.name)) {
+            __classPrivateFieldSet(this, _MLFile_basename, path.basename(target.name), "f");
+            __classPrivateFieldSet(this, _MLFile_dirname, path.dirname(target.name), "f");
         }
         else {
-            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");
+            __classPrivateFieldSet(this, _MLFile_basename, target.name ?? '<AnonymousFile>', "f");
+            __classPrivateFieldSet(this, _MLFile_dirname, target.workspace ?? process.cwd(), "f");
         }
-        tslib_1.__classPrivateFieldSet(this, _MLFile_code, target.sourceCode, "f");
-        tslib_1.__classPrivateFieldSet(this, _MLFile_type, 'code-base', "f");
+        __classPrivateFieldSet(this, _MLFile_code, target.sourceCode, "f");
+        __classPrivateFieldSet(this, _MLFile_type, 'code-base', "f");
     }
     get dirname() {
-        return tslib_1.__classPrivateFieldGet(this, _MLFile_dirname, "f");
+        return __classPrivateFieldGet(this, _MLFile_dirname, "f");
     }
     /**
      * Normalized `MLFile.dirname`
@@ -54,16 +50,16 @@ class MLFile {
         return pathNormalize(this.path);
     }
     get path() {
-        return path_1.default.resolve(tslib_1.__classPrivateFieldGet(this, _MLFile_dirname, "f"), tslib_1.__classPrivateFieldGet(this, _MLFile_basename, "f"));
+        return path.resolve(__classPrivateFieldGet(this, _MLFile_dirname, "f"), __classPrivateFieldGet(this, _MLFile_basename, "f"));
     }
     async dirExists() {
-        return !!(await stat(tslib_1.__classPrivateFieldGet(this, _MLFile_dirname, "f")));
+        return !!(await stat(__classPrivateFieldGet(this, _MLFile_dirname, "f")));
     }
     async getCode() {
-        if (tslib_1.__classPrivateFieldGet(this, _MLFile_code, "f") != null) {
-            return tslib_1.__classPrivateFieldGet(this, _MLFile_code, "f");
+        if (__classPrivateFieldGet(this, _MLFile_code, "f") != null) {
+            return __classPrivateFieldGet(this, _MLFile_code, "f");
         }
-        if (tslib_1.__classPrivateFieldGet(this, _MLFile_type, "f") === 'file-base' && (await this.isExist())) {
+        if (__classPrivateFieldGet(this, _MLFile_type, "f") === 'file-base' && (await this.isExist())) {
             return await this._fetch();
         }
         return '';
@@ -71,51 +67,51 @@ class MLFile {
     ignored(globPath) {
         globPath = typeof globPath === 'string' ? [globPath] : globPath;
         const normalizedPaths = globPath.map(p => pathNormalize(p, true));
-        const ig = (0, ignore_1.default)().add(normalizedPaths);
+        // @ts-ignore
+        const ig = ignore().add(normalizedPaths);
         const ignored = ig.ignores(pathNormalize(this.nPath, true));
         return ignored;
     }
     async isExist() {
-        if (tslib_1.__classPrivateFieldGet(this, _MLFile_type, "f") === 'code-base') {
+        if (__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') {
+        if (__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));
+        return minimatch(this.nPath, pathNormalize(globPath));
     }
     setCode(code) {
-        if (tslib_1.__classPrivateFieldGet(this, _MLFile_type, "f") === 'file-base') {
+        if (__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");
+        __classPrivateFieldSet(this, _MLFile_code, code, "f");
     }
     async _fetch() {
-        const code = await fs_1.promises.readFile(this.path, { encoding: 'utf-8' });
-        tslib_1.__classPrivateFieldSet(this, _MLFile_code, code, "f");
+        const code = await fs.readFile(this.path, { encoding: 'utf-8' });
+        __classPrivateFieldSet(this, _MLFile_code, code, "f");
         return code;
     }
     async _stat() {
-        if (tslib_1.__classPrivateFieldGet(this, _MLFile_stat, "f")) {
-            return tslib_1.__classPrivateFieldGet(this, _MLFile_stat, "f");
+        if (__classPrivateFieldGet(this, _MLFile_stat, "f")) {
+            return __classPrivateFieldGet(this, _MLFile_stat, "f");
         }
-        tslib_1.__classPrivateFieldSet(this, _MLFile_stat, await stat(this.path), "f");
-        return tslib_1.__classPrivateFieldGet(this, _MLFile_stat, "f");
+        __classPrivateFieldSet(this, _MLFile_stat, await stat(this.path), "f");
+        return __classPrivateFieldGet(this, _MLFile_stat, "f");
     }
 }
-exports.MLFile = MLFile;
 _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);
+        return await fs.stat(filePath);
     }
     catch (err) {
         if (
@@ -134,14 +130,14 @@ function pathNormalize(filePath, relative = false) {
         filePath = filePath.slice(1);
     }
     // Remove the local disk scheme of Windows OS
-    if (path_1.default.isAbsolute(filePath)) {
+    if (path.isAbsolute(filePath)) {
         filePath = filePath.replace(/^[a-z]+:/i, '');
         if (relative) {
-            filePath = path_1.default.relative(path_1.default.sep, filePath);
+            filePath = path.relative(path.sep, filePath);
         }
     }
     // Replace the separator of Windows OS
-    filePath = filePath.split(path_1.default.sep).join('/');
+    filePath = filePath.split(path.sep).join('/');
     if (hasBang) {
         filePath = `!${filePath}`;
     }

package/lib/resolve-files.d.ts

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

package/lib/resolve-files.js

@@ -1,17 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveFiles = void 0;
-const ml_file_1 = require("./ml-file");
-async function resolveFiles(targetList) {
+import { getAnonymousFile, getFiles } from './ml-file/index.js';
+export async function resolveFiles(targetList) {
     const res = [];
     for (const target of targetList) {
         if (typeof target === 'string') {
-            const file = await (0, ml_file_1.getFiles)(target);
+            const file = await getFiles(target);
             res.push(...file);
             continue;
         }
-        res.push((0, ml_file_1.getAnonymousFile)(target.sourceCode, target.workspace, target.name));
+        res.push(getAnonymousFile(target.sourceCode, target.workspace, target.name));
     }
     return res;
 }
-exports.resolveFiles = resolveFiles;

package/lib/resolve-parser.d.ts

@@ -1,4 +1,4 @@
-import type { MLFile } from './ml-file';
+import type { MLFile } from './ml-file/index.js';
 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<{

package/lib/resolve-parser.js

@@ -1,20 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveParser = void 0;
-const tslib_1 = require("tslib");
-const path_1 = tslib_1.__importDefault(require("path"));
-const utils_1 = require("./utils");
+import path from 'node:path';
+import { toRegexp } from './utils.js';
 const parsers = new Map();
-async function resolveParser(file, parserConfig, parserOptions) {
+export async function resolveParser(file, parserConfig, parserOptions) {
     parserConfig = {
         ...parserConfig,
         '/\\.html?$/i': '@markuplint/html-parser',
     };
-    parserOptions = parserOptions !== null && parserOptions !== void 0 ? parserOptions : {};
+    parserOptions = parserOptions ?? {};
     let parserModName = '@markuplint/html-parser';
     let matched = false;
     for (const pattern of Object.keys(parserConfig)) {
-        if (path_1.default.basename(file.path).match((0, utils_1.toRegexp)(pattern))) {
+        if (path.basename(file.path).match(toRegexp(pattern))) {
             const modName = parserConfig[pattern];
             if (!modName) {
                 continue;
@@ -32,12 +28,11 @@ async function resolveParser(file, parserConfig, parserOptions) {
         matched,
     };
 }
-exports.resolveParser = resolveParser;
 async function importParser(parserModName) {
     const entity = parsers.get(parserModName);
     if (entity) {
         return entity;
     }
-    const parser = await Promise.resolve(`${parserModName}`).then(s => tslib_1.__importStar(require(s)));
+    const parser = await import(parserModName);
     return parser;
 }

package/lib/resolve-plugins.js

@@ -1,31 +1,5 @@
-"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.cacheClear = exports.resolvePlugins = void 0;
 const cache = new Map();
-async function resolvePlugins(pluginPaths) {
+export async function resolvePlugins(pluginPaths) {
     if (!pluginPaths) {
         return [];
     }
@@ -33,11 +7,9 @@ async function resolvePlugins(pluginPaths) {
     // Clone
     return plugins.slice();
 }
-exports.resolvePlugins = resolvePlugins;
-function cacheClear() {
+export function cacheClear() {
     cache.clear();
 }
-exports.cacheClear = cacheClear;
 async function importPlugin(pluginPath) {
     const config = getPluginConfig(pluginPath);
     const cached = cache.get(config.name);
@@ -76,7 +48,7 @@ function getPluginConfig(pluginPath) {
     return pluginPath;
 }
 async function failSafeImport(name) {
-    const res = await Promise.resolve(`${name}`).then(s => __importStar(require(s))).catch(e => e);
+    const res = await import(name).catch(e => e);
     if ('code' in res && res === 'MODULE_NOT_FOUND') {
         return null;
     }

package/lib/resolve-rules.js

@@ -1,33 +1,7 @@
-"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.resolveRules = void 0;
-const ml_core_1 = require("@markuplint/ml-core");
-const auto_load_rules_1 = require("./auto-load-rules");
+import { MLRule } from '@markuplint/ml-core';
+import { autoLoadRules } from './auto-load-rules.js';
 let cachedPresetRules = null;
-async function resolveRules(plugins, ruleset, importPreset, 
+export async function resolveRules(plugins, ruleset, importPreset, 
 /**
  * @deprecated
  */
@@ -38,7 +12,7 @@ autoLoad) {
             return;
         }
         Object.entries(plugin.rules).forEach(([name, seed]) => {
-            const rule = new ml_core_1.MLRule({
+            const rule = new MLRule({
                 name: `${plugin.name}/${name}`,
                 ...seed,
             });
@@ -46,7 +20,7 @@ autoLoad) {
         });
     });
     if (autoLoad) {
-        const { rules: additionalRules } = await (0, auto_load_rules_1.autoLoadRules)(ruleset);
+        const { rules: additionalRules } = await autoLoadRules(ruleset);
         additionalRules.forEach(rule => {
             rules.push(rule);
         });
@@ -54,15 +28,15 @@ autoLoad) {
     // Clone
     return rules.slice();
 }
-exports.resolveRules = resolveRules;
 async function importPresetRules() {
     if (cachedPresetRules) {
         return cachedPresetRules.slice();
     }
     const modName = '@markuplint/rules';
-    const presetRules = (await Promise.resolve(`${modName}`).then(s => __importStar(require(s)))).default;
+    const mod = await import(modName);
+    const presetRules = mod.default;
     const ruleList = Object.entries(presetRules).map(([name, seed]) => {
-        const rule = new ml_core_1.MLRule({
+        const rule = new MLRule({
             name,
             ...seed,
         });

package/lib/resolve-specs.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveSpecs = void 0;
-const tslib_1 = require("tslib");
-const path_1 = tslib_1.__importDefault(require("path"));
-const utils_1 = require("./utils");
+import path from 'node:path';
+import { toRegexp } from './utils.js';
 const caches = new Map();
 /**
  * Loading and importing form specs.
@@ -35,7 +31,7 @@ const caches = new Map();
  * @param specConfig The `spec` property part of the config
  * @returns
  */
-async function resolveSpecs(filePath, specConfig) {
+export async function resolveSpecs(filePath, specConfig) {
     const htmlSpec = await importSpecs('@markuplint/html-spec');
     const extendedSpecs = [];
     if (specConfig) {
@@ -45,7 +41,7 @@ async function resolveSpecs(filePath, specConfig) {
         }
         else {
             for (const pattern of Object.keys(specConfig)) {
-                if (path_1.default.basename(filePath).match((0, utils_1.toRegexp)(pattern))) {
+                if (path.basename(filePath).match(toRegexp(pattern))) {
                     const specModName = specConfig[pattern];
                     if (!specModName) {
                         continue;
@@ -61,7 +57,6 @@ async function resolveSpecs(filePath, specConfig) {
         schemas,
     };
 }
-exports.resolveSpecs = resolveSpecs;
 async function importSpecs(specModName) {
     {
         // @ts-ignore
@@ -70,7 +65,7 @@ async function importSpecs(specModName) {
             return spec;
         }
     }
-    const spec = (await Promise.resolve(`${specModName}`).then(s => tslib_1.__importStar(require(s)))).default;
+    const spec = (await import(specModName)).default;
     // @ts-ignore
     caches.set(specModName, spec);
     return spec;

package/lib/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/lib/utils.js

@@ -1,24 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toRegexp = exports.fileExists = exports.uuid = void 0;
-const tslib_1 = require("tslib");
-const fs_1 = tslib_1.__importDefault(require("fs"));
+import fs from 'node:fs';
 let uuidNum = 0;
-function uuid() {
+export function uuid() {
     const out = `${uuidNum}`;
     uuidNum++;
     return out;
 }
-exports.uuid = uuid;
-function fileExists(filePath) {
-    return fs_1.default.existsSync(filePath);
+export function fileExists(filePath) {
+    return fs.existsSync(filePath);
 }
-exports.fileExists = fileExists;
-function toRegexp(pattern) {
+export function toRegexp(pattern) {
     const matched = pattern.match(/^\/(.+)\/([ig]*)$/i);
     if (matched && matched[1]) {
         return new RegExp(matched[1], matched[2]);
     }
     return pattern;
 }
-exports.toRegexp = toRegexp;

package/package.json

@@ -1,13 +1,18 @@
 {
 	"name": "@markuplint/file-resolver",
-	"version": "3.13.0",
+	"version": "4.0.0-alpha.2",
 	"description": "The file resolver of markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
 	"license": "MIT",
 	"private": false,
-	"main": "lib/index.js",
-	"types": "lib/index.d.ts",
+	"type": "module",
+	"exports": {
+		".": {
+			"import": "./lib/index.js"
+		}
+	},
+	"types": "./lib/index.d.ts",
 	"publishConfig": {
 		"access": "public"
 	},
@@ -19,24 +24,23 @@
 		"clean": "tsc --build --clean"
 	},
 	"devDependencies": {
-		"@types/node": "20.6.0"
+		"@types/node": "20.8.3"
 	},
 	"dependencies": {
-		"@markuplint/html-parser": "3.11.0",
-		"@markuplint/ml-ast": "3.2.0",
-		"@markuplint/ml-config": "3.12.0",
-		"@markuplint/ml-core": "3.13.0",
-		"@markuplint/ml-spec": "3.12.0",
-		"@markuplint/parser-utils": "3.11.0",
-		"@markuplint/selector": "3.12.0",
-		"@markuplint/shared": "3.8.0",
-		"cosmiconfig": "^8.3.5",
-		"cosmiconfig-typescript-loader": "^5.0.0",
-		"glob": "^10.3.4",
+		"@markuplint/html-parser": "4.0.0-alpha.2",
+		"@markuplint/ml-ast": "4.0.0-alpha.2",
+		"@markuplint/ml-config": "4.0.0-alpha.2",
+		"@markuplint/ml-core": "4.0.0-alpha.2",
+		"@markuplint/ml-spec": "4.0.0-alpha.2",
+		"@markuplint/parser-utils": "4.0.0-alpha.2",
+		"@markuplint/selector": "4.0.0-alpha.2",
+		"@markuplint/shared": "4.0.0-alpha.2",
+		"cosmiconfig": "^8.3.6",
+		"glob": "^10.3.6",
 		"ignore": "^5.2.4",
 		"jsonc": "^2.0.0",
 		"minimatch": "^9.0.3",
 		"tslib": "^2.6.2"
 	},
-	"gitHead": "ef31aef8f2fff319d0f692feead332ec5fc5c7cf"
+	"gitHead": "51ad52c760435641f9bff8685707d8178b0787eb"
 }