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

package/lib/auto-load-rules.js

@@ -1,36 +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;
-};
-var _a, _b;
-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)) {
@@ -41,7 +14,7 @@ async function autoLoadRules(ruleset) {
         }
         let seed = null;
         try {
-            const _module = await (_a = `@markuplint/rule-${ruleName}`, Promise.resolve().then(() => __importStar(require(_a))));
+            const _module = await import(`@markuplint/rule-${ruleName}`);
             seed = _module.default;
             if (!(seed && 'defaultValue' in seed && 'defaultOptions' in seed && 'verify' in seed)) {
                 seed = null;
@@ -51,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,
             });
@@ -60,7 +33,7 @@ async function autoLoadRules(ruleset) {
             continue;
         }
         try {
-            const _module = await (_b = `markuplint-rule-${ruleName}`, Promise.resolve().then(() => __importStar(require(_b))));
+            const _module = await import(`markuplint-rule-${ruleName}`);
             seed = _module.default;
             if (!(seed && 'defaultValue' in seed && 'defaultOptions' in seed && 'verify' in seed)) {
                 seed = null;
@@ -70,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,
             });
@@ -86,4 +59,3 @@ async function autoLoadRules(ruleset) {
         errors: errors.slice(),
     };
 }
-exports.autoLoadRules = autoLoadRules;

package/lib/config-provider.d.ts

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

package/lib/config-provider.js

@@ -1,16 +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 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());
@@ -18,28 +20,35 @@ class ConfigProvider {
         _ConfigProvider_store.set(this, new Map());
     }
     async resolve(targetFile, names, cache = true) {
-        var _a;
         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(utils_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 plugins = await (0, resolve_plugins_1.resolvePlugins)(configSet.config.plugins);
-        if (tslib_1.__classPrivateFieldGet(this, _ConfigProvider_held, "f").size) {
-            const extendHelds = Array.from(tslib_1.__classPrivateFieldGet(this, _ConfigProvider_held, "f").values());
+        const filePath = Array.from(configSet.files).reverse()[0];
+        if (!filePath) {
+            throw new ConfigParserError('Config file not found', {
+                filePath: targetFile.path,
+            });
+        }
+        const errors = this._validateConfig(configSet.config, filePath);
+        configSet.errs.push(...errors);
+        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] = held.match(/^([a-z]+:)([^/]+)(?:\/(.+))?$/) || [];
+                const [, prefix, namespace, name] = held.match(/^([a-z]+:)([^/]+)(?:\/(.+))?$/) ?? [];
                 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];
+                        const config = plugin?.configs?.[name ?? ''];
                         if (config) {
                             this.set(config, held);
                         }
@@ -48,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) {
@@ -56,9 +65,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;
                 }
             }
         }
@@ -66,59 +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 || (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) {
-        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] = filePath.match(/^markuplint:(.+)$/i) || [];
-            const config = await (0, ml_core_1.getPreset)(name);
-            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);
@@ -128,11 +138,11 @@ class ConfigProvider {
             }
         }
         const configs = Array.from(resolvedKeys)
-            .map(name => tslib_1.__classPrivateFieldGet(this, _ConfigProvider_store, "f").get(name))
-            .filter(utils_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,
@@ -140,37 +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) {
         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 = tslib_1.__classPrivateFieldGet(this, _ConfigProvider_store, "f").get(key) || 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 ? (Array.isArray(config.extends) ? config.extends : [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);
@@ -185,23 +195,40 @@ class ConfigProvider {
         stack.add(key);
         return { stack, errs };
     }
+    _validateConfig(config, filePath) {
+        const errors = [];
+        config.nodeRules?.forEach(rule => {
+            if (rule.selector) {
+                try {
+                    createSelector(rule.selector);
+                }
+                catch (error) {
+                    if (error instanceof InvalidSelectorError) {
+                        errors.push(new ConfigParserError(error.message, {
+                            filePath,
+                            raw: rule.selector,
+                        }));
+                    }
+                }
+            }
+        });
+        return errors;
+    }
 }
-exports.ConfigProvider = ConfigProvider;
 _ConfigProvider_cache = new WeakMap(), _ConfigProvider_held = new WeakMap(), _ConfigProvider_recursiveLoadKeyAndDepth = new WeakMap(), _ConfigProvider_store = new WeakMap();
 async function load(filePath, cache) {
-    var _a;
-    if (!(0, utils_1.fileExists)(filePath) && moduleExists(filePath)) {
-        const mod = await (_a = filePath, Promise.resolve().then(() => tslib_1.__importStar(require(_a))));
-        const config = (mod === null || mod === void 0 ? void 0 : mod.default) || 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;
@@ -212,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;
@@ -238,25 +265,48 @@ function pathResolve(dir, filePath, resolveProps, resolveKey = false) {
     // @ts-ignore
     return res;
 }
-function resolve(dir, pathOrModName) {
-    if (moduleExists(pathOrModName) || isPreset(pathOrModName) || isPlugin(pathOrModName)) {
+async function resolve(dir, pathOrModName) {
+    if ((await moduleExists(pathOrModName)) || isPreset(pathOrModName) || isPlugin(pathOrModName)) {
         return pathOrModName;
     }
-    return path_1.default.resolve(dir, pathOrModName);
+    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,31 +1,28 @@
-"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 cosmiconfig_1 = require("cosmiconfig");
-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: {
         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);
-    const result = await explorer.search(dir);
+    dir = path.dirname(dir);
+    const result = await explorer.search(dir).catch(cacheConfigError(dir));
     if (!result || result.isEmpty) {
         return null;
     }
@@ -34,12 +31,11 @@ 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();
     }
-    const result = await explorer.load(filePath);
+    const result = await explorer.load(filePath).catch(cacheConfigError(filePath));
     if (!result || result.isEmpty) {
         return null;
     }
@@ -48,4 +44,24 @@ async function load(filePath, cacheClear) {
         config: result.config,
     };
 }
-exports.load = load;
+class ConfigLoadError extends Error {
+    constructor(message, filePath) {
+        super(message + ` in ${filePath}`);
+        this.name = 'ConfigLoadError';
+    }
+}
+function cacheConfigError(fileOrDirPath) {
+    return (reason) => {
+        if (reason instanceof Error) {
+            switch (reason.name) {
+                case 'YAMLException':
+                    throw new ConfigParserError(reason.message, {
+                        // @ts-ignore
+                        filePath: reason.filepath ?? fileOrDirPath,
+                    });
+            }
+            throw new ConfigLoadError(reason.message, fileOrDirPath);
+        }
+        throw reason;
+    };
+}

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
  *