@markuplint/file-resolver 3.0.0-dev.25 → 3.0.0-dev.300

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

@@ -1,9 +1,5 @@
-"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 get_file_1 = require("./get-file");
+import { glob } from 'glob';
+import { getFile } from './get-file.js';
 /**
  * Get files
  *
@@ -11,15 +7,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(() => []);
-    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,6 +14,7 @@ export declare class MLFile {
     get path(): string;
     dirExists(): Promise<boolean>;
     getCode(): Promise<string>;
+    ignored(globPath: string | readonly string[]): any;
     isExist(): Promise<boolean>;
     isFile(): Promise<boolean>;
     matches(globPath: string): boolean;

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

@@ -1,12 +1,10 @@
-"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 minimatch_1 = tslib_1.__importDefault(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) {
         _MLFile_basename.set(this, void 0);
         _MLFile_code.set(this, void 0);
@@ -19,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, target.name || '<AnonymousFile>', "f");
-            tslib_1.__classPrivateFieldSet(this, _MLFile_dirname, target.workspace || 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`
@@ -52,61 +50,68 @@ 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 '';
     }
+    ignored(globPath) {
+        globPath = typeof globPath === 'string' ? [globPath] : globPath;
+        const normalizedPaths = globPath.map(p => pathNormalize(p, true));
+        // @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.default)(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 (
@@ -119,12 +124,22 @@ async function stat(filePath) {
         throw err;
     }
 }
-function pathNormalize(filePath) {
+function pathNormalize(filePath, relative = false) {
+    const hasBang = filePath.startsWith('!');
+    if (hasBang) {
+        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.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}`;
+    }
     return 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[]>;
+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,7 +1,7 @@
-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: MLFile, parserConfig?: ParserConfig, parserOptions?: ParserOptions): Promise<{
+export declare function resolveParser(file: Readonly<MLFile>, parserConfig?: ParserConfig, parserOptions?: ParserOptions): Promise<{
     parserModName: string;
     parser: MLMarkupLanguageParser;
     parserOptions: ParserOptions;

package/lib/resolve-parser.js

@@ -1,25 +1,23 @@
-"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 || {};
+    parserOptions = 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.toRegexp)(pattern))) {
-                parserModName = parserConfig[pattern];
-                matched = true;
-                break;
+    for (const pattern of Object.keys(parserConfig)) {
+        if (path.basename(file.path).match(toRegexp(pattern))) {
+            const modName = parserConfig[pattern];
+            if (!modName) {
+                continue;
             }
+            parserModName = modName;
+            matched = true;
+            break;
         }
     }
     const parser = await importParser(parserModName);
@@ -30,13 +28,11 @@ async function resolveParser(file, parserConfig, parserOptions) {
         matched,
     };
 }
-exports.resolveParser = resolveParser;
 async function importParser(parserModName) {
-    var _a;
     const entity = parsers.get(parserModName);
     if (entity) {
         return entity;
     }
-    const parser = await (_a = parserModName, Promise.resolve().then(() => tslib_1.__importStar(require(_a))));
+    const parser = await import(parserModName);
     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;

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);
@@ -55,15 +27,19 @@ async function importPlugin(pluginPath) {
         ...pluginCreator.create(config.settings),
     };
     cache.set(plugin.name, plugin);
-    if (!plugin.name) {
-        plugin.name = config.name
+    let name = plugin.name;
+    if (!name) {
+        name = config.name
             .toLowerCase()
             .replace(/^(?:markuplint-rule-|@markuplint\/rule-)/i, '')
             .replace(/\s+|\/|\\|\./g, '-');
         // eslint-disable-next-line no-console
-        console.info(`The plugin name became "${plugin.name}"`);
+        console.info(`The plugin name became "${name}"`);
     }
-    return plugin;
+    return {
+        ...plugin,
+        name,
+    };
 }
 function getPluginConfig(pluginPath) {
     if (typeof pluginPath === 'string') {
@@ -72,8 +48,7 @@ function getPluginConfig(pluginPath) {
     return pluginPath;
 }
 async function failSafeImport(name) {
-    var _a;
-    const res = await (_a = name, Promise.resolve().then(() => __importStar(require(_a)))).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.d.ts

@@ -1,7 +1,6 @@
 import type { AnyMLRule, Ruleset, Plugin } from '@markuplint/ml-core';
-import { MLRule } from '@markuplint/ml-core';
-export declare function resolveRules(plugins: Plugin[], ruleset: Ruleset, importPreset: boolean, 
+export declare function resolveRules(plugins: readonly Plugin[], ruleset: Ruleset, importPreset: boolean, 
 /**
  * @deprecated
  */
-autoLoad: boolean): Promise<AnyMLRule[] | MLRule<any, any>[]>;
+autoLoad: boolean): Promise<Readonly<AnyMLRule>[]>;

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,16 +28,15 @@ autoLoad) {
     // Clone
     return rules.slice();
 }
-exports.resolveRules = resolveRules;
 async function importPresetRules() {
-    var _a;
     if (cachedPresetRules) {
         return cachedPresetRules.slice();
     }
     const modName = '@markuplint/rules';
-    const presetRules = (await (_a = modName, Promise.resolve().then(() => __importStar(require(_a))))).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) {
@@ -43,16 +39,13 @@ async function resolveSpecs(filePath, specConfig) {
             const spec = await importSpecs(specConfig);
             extendedSpecs.push(spec);
         }
-        else if (Array.isArray(specConfig)) {
-            for (const specModName of specConfig) {
-                const spec = await importSpecs(specModName);
-                extendedSpecs.push(spec);
-            }
-        }
         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;
+                    }
                     const spec = await importSpecs(specModName);
                     extendedSpecs.push(spec);
                 }
@@ -64,9 +57,7 @@ async function resolveSpecs(filePath, specConfig) {
         schemas,
     };
 }
-exports.resolveSpecs = resolveSpecs;
 async function importSpecs(specModName) {
-    var _a;
     {
         // @ts-ignore
         const spec = caches.get(specModName);
@@ -74,7 +65,7 @@ async function importSpecs(specModName) {
             return spec;
         }
     }
-    const spec = (await (_a = specModName, Promise.resolve().then(() => tslib_1.__importStar(require(_a))))).default;
+    const spec = (await import(specModName)).default;
     // @ts-ignore
     caches.set(specModName, spec);
     return spec;

package/lib/types.d.ts

@@ -1,23 +1,22 @@
 import type { Config } from '@markuplint/ml-config';
 import type { Plugin } from '@markuplint/ml-core';
-export type Nullable<T> = T | null | undefined;
 export interface ConfigSet {
-    config: Config;
-    plugins: Plugin[];
-    files: Set<string>;
-    errs: Error[];
+    readonly config: Config;
+    readonly plugins: readonly Plugin[];
+    readonly files: ReadonlySet<string>;
+    readonly errs: readonly Readonly<Error>[];
 }
 export type Target = string | {
     /**
      * Target source code of evaluation
      */
-    sourceCode: string;
+    readonly sourceCode: string;
     /**
      * File names when `sourceCodes`
      */
-    name?: string;
+    readonly name?: string;
     /**
      * Workspace path when `sourceCodes`
      */
-    workspace?: string;
+    readonly workspace?: string;
 };

package/lib/types.js

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

package/lib/utils.d.ts

@@ -1,5 +1,3 @@
-import type { Nullable } from './types';
-export declare function nonNullableFilter<T>(item: Nullable<T>): item is T;
 export declare function uuid(): string;
 export declare function fileExists(filePath: string): boolean;
 export declare function toRegexp(pattern: string): string | RegExp;

package/lib/utils.js

@@ -1,28 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toRegexp = exports.fileExists = exports.uuid = exports.nonNullableFilter = void 0;
-const tslib_1 = require("tslib");
-const fs_1 = tslib_1.__importDefault(require("fs"));
-function nonNullableFilter(item) {
-    return !!item;
-}
-exports.nonNullableFilter = nonNullableFilter;
+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) {
+    if (matched && matched[1]) {
         return new RegExp(matched[1], matched[2]);
     }
     return pattern;
 }
-exports.toRegexp = toRegexp;