markuplint 2.0.0 → 2.1.0

package/lib/api/index.d.mts

@@ -0,0 +1,2 @@
+export { default as MLEngine } from './ml-engine.mjs';
+export { lint } from './lint.mjs';

package/lib/api/index.mjs

@@ -0,0 +1,2 @@
+export { default as MLEngine } from './ml-engine.mjs';
+export { lint } from './lint.mjs';

package/lib/api/lint.d.mts

@@ -0,0 +1,4 @@
+import type { MLResultInfo } from '../types.mjs';
+import type { APIOptions } from './types.mjs';
+import type { Target } from '@markuplint/file-resolver';
+export declare function lint(targetList: Target[], options?: APIOptions): Promise<MLResultInfo[]>;

package/lib/api/lint.mjs

@@ -0,0 +1,15 @@
+import { resolveFiles } from '@markuplint/file-resolver';
+import MLEngine from './ml-engine.mjs';
+export async function lint(targetList, options) {
+    const res = [];
+    const files = await resolveFiles(targetList);
+    for (const file of files) {
+        const engine = new MLEngine(file, options);
+        const result = await engine.exec();
+        if (!result) {
+            continue;
+        }
+        res.push(result);
+    }
+    return res;
+}

package/lib/api/ml-engine.d.mts

@@ -0,0 +1,27 @@
+import type { MLResultInfo } from '../types.mjs';
+import type { APIOptions, MLEngineEventMap } from './types.mjs';
+import type { MLFile, Target } from '@markuplint/file-resolver';
+import { StrictEventEmitter } from 'strict-event-emitter';
+declare type MLEngineOptions = {
+    debug?: boolean;
+    watch?: boolean;
+};
+export default class MLEngine extends StrictEventEmitter<MLEngineEventMap> {
+    #private;
+    static toMLFile(target: Target): Promise<MLFile>;
+    constructor(file: MLFile, options?: APIOptions & MLEngineOptions);
+    exec(): Promise<MLResultInfo | null>;
+    setCode(code: string): Promise<void>;
+    close(): Promise<void>;
+    private setup;
+    private provide;
+    private cretateCore;
+    private resolveConfig;
+    private resolveParser;
+    private resolveRuleset;
+    private resolveSchemas;
+    private resolveRules;
+    private i18n;
+    private watch;
+}
+export {};

package/lib/api/ml-engine.d.ts

@@ -3,25 +3,25 @@ import type { APIOptions, MLEngineEventMap } from './types';
 import type { MLFile, Target } from '@markuplint/file-resolver';
 import { StrictEventEmitter } from 'strict-event-emitter';
 declare type MLEngineOptions = {
-	debug?: boolean;
-	watch?: boolean;
+    debug?: boolean;
+    watch?: boolean;
 };
 export default class MLEngine extends StrictEventEmitter<MLEngineEventMap> {
-	#private;
-	static toMLFile(target: Target): Promise<MLFile>;
-	constructor(file: MLFile, options?: APIOptions & MLEngineOptions);
-	exec(): Promise<MLResultInfo | null>;
-	setCode(code: string): Promise<void>;
-	close(): Promise<void>;
-	private setup;
-	private provide;
-	private cretateCore;
-	private resolveConfig;
-	private resolveParser;
-	private resolveRuleset;
-	private resolveSchemas;
-	private resolveRules;
-	private i18n;
-	private watch;
+    #private;
+    static toMLFile(target: Target): Promise<MLFile>;
+    constructor(file: MLFile, options?: APIOptions & MLEngineOptions);
+    exec(): Promise<MLResultInfo | null>;
+    setCode(code: string): Promise<void>;
+    close(): Promise<void>;
+    private setup;
+    private provide;
+    private cretateCore;
+    private resolveConfig;
+    private resolveParser;
+    private resolveRuleset;
+    private resolveSchemas;
+    private resolveRules;
+    private i18n;
+    private watch;
 }
 export {};

package/lib/api/ml-engine.mjs

@@ -0,0 +1,232 @@
+var _MLEngine_file, _MLEngine_options, _MLEngine_core, _MLEngine_watcher;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+import { configProvider, resolveFiles, resolveParser, resolveRules, resolveSpecs } from '@markuplint/file-resolver';
+import { MLCore, convertRuleset } from '@markuplint/ml-core';
+import { FSWatcher } from 'chokidar';
+import { StrictEventEmitter } from 'strict-event-emitter';
+import { log as coreLog, verbosely } from '../debug.mjs';
+import { i18n } from '../i18n.mjs';
+const log = coreLog.extend('ml-engine');
+const fileLog = log.extend('file');
+export default class MLEngine extends StrictEventEmitter {
+    constructor(file, options) {
+        super();
+        _MLEngine_file.set(this, void 0);
+        _MLEngine_options.set(this, void 0);
+        _MLEngine_core.set(this, null);
+        _MLEngine_watcher.set(this, new FSWatcher());
+        __classPrivateFieldSet(this, _MLEngine_file, file, "f");
+        __classPrivateFieldSet(this, _MLEngine_options, options, "f");
+        if (__classPrivateFieldGet(this, _MLEngine_options, "f")?.debug) {
+            verbosely();
+        }
+        if (options?.watch) {
+            __classPrivateFieldGet(this, _MLEngine_watcher, "f").on('all', this.watch.bind(this));
+        }
+        else {
+            __classPrivateFieldGet(this, _MLEngine_watcher, "f").close();
+        }
+    }
+    static async toMLFile(target) {
+        const files = await resolveFiles([target]);
+        return files[0];
+    }
+    async exec() {
+        log('exec: start');
+        const core = await this.setup();
+        if (!core) {
+            log('exec: cancel (unsetuped yet)');
+            return null;
+        }
+        const violations = await core.verify(__classPrivateFieldGet(this, _MLEngine_options, "f")?.fix).catch(e => {
+            if (e instanceof Error) {
+                return e;
+            }
+            throw e;
+        });
+        const sourceCode = await __classPrivateFieldGet(this, _MLEngine_file, "f").getCode();
+        const fixedCode = core.document.toString();
+        if (violations instanceof Error) {
+            this.emit('lint-error', __classPrivateFieldGet(this, _MLEngine_file, "f").path, sourceCode, violations);
+            const errMessage = violations.stack ?? violations.message;
+            log('exec: error %O', errMessage);
+            return {
+                violations: [
+                    {
+                        severity: 'error',
+                        message: errMessage,
+                        ruleId: '@markuplint/ml-core',
+                        line: 0,
+                        col: 0,
+                        raw: '',
+                    },
+                ],
+                filePath: __classPrivateFieldGet(this, _MLEngine_file, "f").path,
+                sourceCode,
+                fixedCode,
+            };
+        }
+        const debugMap = ('debugMap' in core.document && core.document.debugMap()) || null;
+        this.emit('lint', __classPrivateFieldGet(this, _MLEngine_file, "f").path, sourceCode, violations, fixedCode, debugMap);
+        log('exec: end');
+        return {
+            violations,
+            filePath: __classPrivateFieldGet(this, _MLEngine_file, "f").path,
+            sourceCode,
+            fixedCode,
+        };
+    }
+    async setCode(code) {
+        const core = await this.setup();
+        if (!core) {
+            return;
+        }
+        __classPrivateFieldGet(this, _MLEngine_file, "f").setCode(code);
+        core.setCode(code);
+    }
+    async close() {
+        this.removeAllListeners();
+        await __classPrivateFieldGet(this, _MLEngine_watcher, "f").close();
+    }
+    async setup() {
+        if (__classPrivateFieldGet(this, _MLEngine_core, "f")) {
+            return __classPrivateFieldGet(this, _MLEngine_core, "f");
+        }
+        const fabric = await this.provide(false);
+        if (!fabric) {
+            return null;
+        }
+        if (fabric.configErrors) {
+            this.emit('config-errors', __classPrivateFieldGet(this, _MLEngine_file, "f").path, fabric.configErrors);
+        }
+        const core = this.cretateCore(fabric);
+        return core;
+    }
+    async provide(remerge) {
+        const configSet = await this.resolveConfig(remerge);
+        fileLog('Fetched Config files: %O', configSet.files);
+        fileLog('Resolved Config: %O', configSet.config);
+        fileLog('Resolved Plugins: %O', configSet.plugins);
+        fileLog('Resolve Errors: %O', configSet.errs);
+        if (!(await __classPrivateFieldGet(this, _MLEngine_file, "f").isFile())) {
+            this.emit('log', 'file-no-exists', `The file doesn't exist or it is not a file: ${__classPrivateFieldGet(this, _MLEngine_file, "f").path}`);
+            return null;
+        }
+        // Exclude
+        const excludeFiles = configSet.config.excludeFiles || [];
+        for (const excludeFile of excludeFiles) {
+            if (__classPrivateFieldGet(this, _MLEngine_file, "f").matches(excludeFile)) {
+                this.emit('exclude', __classPrivateFieldGet(this, _MLEngine_file, "f").path, excludeFile);
+                return null;
+            }
+        }
+        const { parser, parserOptions, matched } = await this.resolveParser(configSet);
+        const checkingExt = !__classPrivateFieldGet(this, _MLEngine_options, "f")?.ignoreExt;
+        if (checkingExt && !matched) {
+            this.emit('log', 'ext-unmatched', `Avoided linting because a file is unmatched by the extension: ${__classPrivateFieldGet(this, _MLEngine_file, "f").path}`);
+            return null;
+        }
+        const ruleset = this.resolveRuleset(configSet);
+        fileLog('Resolved ruleset: %O', ruleset);
+        const schemas = await this.resolveSchemas(configSet);
+        if (fileLog.enabled) {
+            if (schemas[0].cites.length) {
+                const [, ...additionalSpecs] = schemas;
+                fileLog('Resolved schemas: HTML Standard');
+                for (const additionalSpec of additionalSpecs) {
+                    fileLog('Resolved schemas: %O', additionalSpec);
+                }
+            }
+            else {
+                fileLog('Resolved schemas: %O', schemas);
+            }
+        }
+        const rules = await this.resolveRules(configSet.plugins, ruleset);
+        fileLog('Resolved rules: %O', rules);
+        const locale = await i18n(__classPrivateFieldGet(this, _MLEngine_options, "f")?.locale);
+        if (fileLog.enabled) {
+            fileLog('Loaded %d rules: %O', rules.length, rules.map(r => r.name));
+        }
+        return {
+            parser,
+            parserOptions,
+            ruleset,
+            schemas,
+            rules,
+            locale,
+            configErrors: configSet.errs,
+        };
+    }
+    async cretateCore(fabric) {
+        fileLog('Get source code');
+        const sourceCode = await __classPrivateFieldGet(this, _MLEngine_file, "f").getCode();
+        fileLog('Source code path: %s', __classPrivateFieldGet(this, _MLEngine_file, "f").path);
+        fileLog('Source code size: %dbyte', sourceCode.length);
+        this.emit('code', __classPrivateFieldGet(this, _MLEngine_file, "f").path, sourceCode);
+        const core = new MLCore({
+            sourceCode,
+            filename: __classPrivateFieldGet(this, _MLEngine_file, "f").path,
+            debug: __classPrivateFieldGet(this, _MLEngine_options, "f")?.debug,
+            ...fabric,
+        });
+        __classPrivateFieldSet(this, _MLEngine_core, core, "f");
+        return core;
+    }
+    async resolveConfig(remerge) {
+        const configFilePathsFromTarget = __classPrivateFieldGet(this, _MLEngine_options, "f")?.noSearchConfig
+            ? null
+            : await configProvider.search(__classPrivateFieldGet(this, _MLEngine_file, "f"));
+        this.emit('log', 'configFilePathsFromTarget', configFilePathsFromTarget || 'null');
+        const configKey = __classPrivateFieldGet(this, _MLEngine_options, "f")?.config && configProvider.set(__classPrivateFieldGet(this, _MLEngine_options, "f").config);
+        this.emit('log', 'configKey', configKey || 'null');
+        const configSet = await configProvider.resolve([configFilePathsFromTarget, __classPrivateFieldGet(this, _MLEngine_options, "f")?.configFile, configKey], remerge);
+        this.emit('config', __classPrivateFieldGet(this, _MLEngine_file, "f").path, configSet);
+        if (__classPrivateFieldGet(this, _MLEngine_options, "f")?.watch) {
+            __classPrivateFieldGet(this, _MLEngine_watcher, "f").add(Array.from(configSet.files));
+        }
+        return configSet;
+    }
+    async resolveParser(configSet) {
+        const parser = await resolveParser(__classPrivateFieldGet(this, _MLEngine_file, "f"), configSet.config.parser, configSet.config.parserOptions);
+        this.emit('parser', __classPrivateFieldGet(this, _MLEngine_file, "f").path, parser.parserModName);
+        fileLog('Fetched Parser module: %s', parser.parserModName);
+        return parser;
+    }
+    resolveRuleset(configSet) {
+        const ruleset = convertRuleset(configSet.config);
+        this.emit('ruleset', __classPrivateFieldGet(this, _MLEngine_file, "f").path, ruleset);
+        return ruleset;
+    }
+    async resolveSchemas(configSet) {
+        const { schemas } = await resolveSpecs(__classPrivateFieldGet(this, _MLEngine_file, "f").path, configSet.config.specs);
+        this.emit('schemas', __classPrivateFieldGet(this, _MLEngine_file, "f").path, schemas);
+        return schemas;
+    }
+    async resolveRules(plugins, ruleset) {
+        const rules = await resolveRules(plugins, ruleset, __classPrivateFieldGet(this, _MLEngine_options, "f")?.importPresetRules ?? true, __classPrivateFieldGet(this, _MLEngine_options, "f")?.autoLoad ?? true);
+        if (__classPrivateFieldGet(this, _MLEngine_options, "f")?.rules) {
+            rules.push(...__classPrivateFieldGet(this, _MLEngine_options, "f").rules);
+        }
+        this.emit('rules', __classPrivateFieldGet(this, _MLEngine_file, "f").path, rules);
+        return rules;
+    }
+    async i18n() {
+        const i18nSettings = await i18n(__classPrivateFieldGet(this, _MLEngine_options, "f")?.locale);
+        this.emit('i18n', __classPrivateFieldGet(this, _MLEngine_file, "f").path, i18nSettings);
+        return i18nSettings;
+    }
+    async watch(type, filePath) {
+        this.emit('log', `watch:${type}`, filePath);
+        const fabric = await this.provide(true);
+        if (!fabric) {
+            return;
+        }
+        if (fabric.configErrors) {
+            this.emit('config-errors', __classPrivateFieldGet(this, _MLEngine_file, "f").path, fabric.configErrors);
+        }
+        this.emit('log', 'update:core', __classPrivateFieldGet(this, _MLEngine_file, "f").path);
+        __classPrivateFieldGet(this, _MLEngine_core, "f")?.update(fabric);
+        this.exec();
+    }
+}
+_MLEngine_file = new WeakMap(), _MLEngine_options = new WeakMap(), _MLEngine_core = new WeakMap(), _MLEngine_watcher = new WeakMap();

package/lib/api/types.d.mts

@@ -0,0 +1,43 @@
+import type { ConfigSet } from '@markuplint/file-resolver';
+import type { LocaleSet } from '@markuplint/i18n';
+import type { MLMarkupLanguageParser } from '@markuplint/ml-ast';
+import type { Config, Violation, ParserOptions } from '@markuplint/ml-config';
+import type { AnyMLRule, MLSchema, Ruleset } from '@markuplint/ml-core';
+export declare type APIOptions = {
+    configFile?: string;
+    config?: Config;
+    defaultConfig?: Config;
+    noSearchConfig?: boolean;
+    locale?: string;
+    fix?: boolean;
+    ignoreExt?: boolean;
+    rules?: AnyMLRule[];
+    importPresetRules?: boolean;
+    /**
+     * @deprecated
+     */
+    autoLoad?: boolean;
+};
+export declare type MLFabric = {
+    ruleset: Ruleset;
+    rules: AnyMLRule[];
+    schemas: MLSchema;
+    parser: MLMarkupLanguageParser;
+    parserOptions: ParserOptions;
+    locale: LocaleSet;
+    configErrors?: Error[];
+};
+export declare type MLEngineEventMap = {
+    log: (phase: string, message: string) => void;
+    config: (filePath: string, config: ConfigSet, message?: string) => void;
+    exclude: (filePath: string, setting: string, message?: string) => void;
+    parser: (filePath: string, parser: string, message?: string) => void;
+    ruleset: (filePath: string, ruleset: Ruleset, message?: string) => void;
+    schemas: (filePath: string, schemas: MLSchema, message?: string) => void;
+    rules: (filePath: string, rules: AnyMLRule[], message?: string) => void;
+    i18n: (filePath: string, locale: LocaleSet, message?: string) => void;
+    code: (filePath: string, sourceCode: string, message?: string) => void;
+    lint: (filePath: string, sourceCode: string, violations: Violation[], fixedCode: string, debug: string[] | null, message?: string) => void;
+    'lint-error': (filePath: string, sourceCode: string, error: Error) => void;
+    'config-errors': (filePath: string, errors: Error[]) => void;
+};

package/lib/api/types.d.ts

@@ -4,47 +4,40 @@ import type { MLMarkupLanguageParser } from '@markuplint/ml-ast';
 import type { Config, Violation, ParserOptions } from '@markuplint/ml-config';
 import type { AnyMLRule, MLSchema, Ruleset } from '@markuplint/ml-core';
 export declare type APIOptions = {
-	configFile?: string;
-	config?: Config;
-	defaultConfig?: Config;
-	noSearchConfig?: boolean;
-	locale?: string;
-	fix?: boolean;
-	ignoreExt?: boolean;
-	rules?: AnyMLRule[];
-	importPresetRules?: boolean;
-	/**
-	 * @deprecated
-	 */
-	autoLoad?: boolean;
+    configFile?: string;
+    config?: Config;
+    defaultConfig?: Config;
+    noSearchConfig?: boolean;
+    locale?: string;
+    fix?: boolean;
+    ignoreExt?: boolean;
+    rules?: AnyMLRule[];
+    importPresetRules?: boolean;
+    /**
+     * @deprecated
+     */
+    autoLoad?: boolean;
 };
 export declare type MLFabric = {
-	ruleset: Ruleset;
-	rules: AnyMLRule[];
-	schemas: MLSchema;
-	parser: MLMarkupLanguageParser;
-	parserOptions: ParserOptions;
-	locale: LocaleSet;
-	configErrors?: Error[];
+    ruleset: Ruleset;
+    rules: AnyMLRule[];
+    schemas: MLSchema;
+    parser: MLMarkupLanguageParser;
+    parserOptions: ParserOptions;
+    locale: LocaleSet;
+    configErrors?: Error[];
 };
 export declare type MLEngineEventMap = {
-	log: (phase: string, message: string) => void;
-	config: (filePath: string, config: ConfigSet, message?: string) => void;
-	exclude: (filePath: string, setting: string, message?: string) => void;
-	parser: (filePath: string, parser: string, message?: string) => void;
-	ruleset: (filePath: string, ruleset: Ruleset, message?: string) => void;
-	schemas: (filePath: string, schemas: MLSchema, message?: string) => void;
-	rules: (filePath: string, rules: AnyMLRule[], message?: string) => void;
-	i18n: (filePath: string, locale: LocaleSet, message?: string) => void;
-	code: (filePath: string, sourceCode: string, message?: string) => void;
-	lint: (
-		filePath: string,
-		sourceCode: string,
-		violations: Violation[],
-		fixedCode: string,
-		debug: string[] | null,
-		message?: string,
-	) => void;
-	'lint-error': (filePath: string, sourceCode: string, error: Error) => void;
-	'config-errors': (filePath: string, errors: Error[]) => void;
+    log: (phase: string, message: string) => void;
+    config: (filePath: string, config: ConfigSet, message?: string) => void;
+    exclude: (filePath: string, setting: string, message?: string) => void;
+    parser: (filePath: string, parser: string, message?: string) => void;
+    ruleset: (filePath: string, ruleset: Ruleset, message?: string) => void;
+    schemas: (filePath: string, schemas: MLSchema, message?: string) => void;
+    rules: (filePath: string, rules: AnyMLRule[], message?: string) => void;
+    i18n: (filePath: string, locale: LocaleSet, message?: string) => void;
+    code: (filePath: string, sourceCode: string, message?: string) => void;
+    lint: (filePath: string, sourceCode: string, violations: Violation[], fixedCode: string, debug: string[] | null, message?: string) => void;
+    'lint-error': (filePath: string, sourceCode: string, error: Error) => void;
+    'config-errors': (filePath: string, errors: Error[]) => void;
 };

package/lib/api/types.mjs

@@ -0,0 +1 @@
+export {};

package/lib/api/v1.d.mts

@@ -0,0 +1,51 @@
+import type { Config, RuleConfigValue } from '@markuplint/ml-config';
+import type { MLRule } from '@markuplint/ml-core';
+/**
+ * @deprecated
+ * @param options
+ * @returns
+ */
+export declare function lint_v1(options: {
+    /**
+     * Glob pattern
+     */
+    files?: string | string[];
+    /**
+     * Target source code of evaluation
+     */
+    sourceCodes?: string | string[];
+    /**
+     * File names when `sourceCodes`
+     */
+    names?: string | string[];
+    /**
+     * Workspace path when `sourceCodes`
+     */
+    workspace?: string;
+    /**
+     * Configure file or object
+     */
+    config?: string | Config;
+    /**
+     * The config applied when not resolved from files or set it explicitly.
+     */
+    defaultConfig?: Config;
+    /**
+     * Rules (default: `@markuplint/rules`)
+     */
+    rules?: MLRule<RuleConfigValue, unknown>[];
+    /**
+     * Auto resolve rules
+     *
+     * Auto importing form *node_modules* when set `@markuplint/rule-{RULE_NAME}` or `markuplint-rule-{RULE_NAME}` in config rules
+     */
+    rulesAutoResolve?: boolean;
+    /**
+     * Auto fix
+     */
+    fix?: boolean;
+    /**
+     * Locale
+     */
+    locale?: string;
+}): Promise<import("../types.mjs").MLResultInfo[]>;

package/lib/api/v1.d.ts

@@ -6,46 +6,46 @@ import type { MLRule } from '@markuplint/ml-core';
  * @returns
  */
 export declare function lint_v1(options: {
-	/**
-	 * Glob pattern
-	 */
-	files?: string | string[];
-	/**
-	 * Target source code of evaluation
-	 */
-	sourceCodes?: string | string[];
-	/**
-	 * File names when `sourceCodes`
-	 */
-	names?: string | string[];
-	/**
-	 * Workspace path when `sourceCodes`
-	 */
-	workspace?: string;
-	/**
-	 * Configure file or object
-	 */
-	config?: string | Config;
-	/**
-	 * The config applied when not resolved from files or set it explicitly.
-	 */
-	defaultConfig?: Config;
-	/**
-	 * Rules (default: `@markuplint/rules`)
-	 */
-	rules?: MLRule<RuleConfigValue, unknown>[];
-	/**
-	 * Auto resolve rules
-	 *
-	 * Auto importing form *node_modules* when set `@markuplint/rule-{RULE_NAME}` or `markuplint-rule-{RULE_NAME}` in config rules
-	 */
-	rulesAutoResolve?: boolean;
-	/**
-	 * Auto fix
-	 */
-	fix?: boolean;
-	/**
-	 * Locale
-	 */
-	locale?: string;
-}): Promise<import('..').MLResultInfo[]>;
+    /**
+     * Glob pattern
+     */
+    files?: string | string[];
+    /**
+     * Target source code of evaluation
+     */
+    sourceCodes?: string | string[];
+    /**
+     * File names when `sourceCodes`
+     */
+    names?: string | string[];
+    /**
+     * Workspace path when `sourceCodes`
+     */
+    workspace?: string;
+    /**
+     * Configure file or object
+     */
+    config?: string | Config;
+    /**
+     * The config applied when not resolved from files or set it explicitly.
+     */
+    defaultConfig?: Config;
+    /**
+     * Rules (default: `@markuplint/rules`)
+     */
+    rules?: MLRule<RuleConfigValue, unknown>[];
+    /**
+     * Auto resolve rules
+     *
+     * Auto importing form *node_modules* when set `@markuplint/rule-{RULE_NAME}` or `markuplint-rule-{RULE_NAME}` in config rules
+     */
+    rulesAutoResolve?: boolean;
+    /**
+     * Auto fix
+     */
+    fix?: boolean;
+    /**
+     * Locale
+     */
+    locale?: string;
+}): Promise<import("..").MLResultInfo[]>;

package/lib/api/v1.mjs

@@ -0,0 +1,39 @@
+import { lint } from './lint.mjs';
+/**
+ * @deprecated
+ * @param options
+ * @returns
+ */
+export async function lint_v1(options) {
+    const filePathList = options.files ? (Array.isArray(options.files) ? options.files : [options.files]) : [];
+    const codes = options.sourceCodes
+        ? Array.isArray(options.sourceCodes)
+            ? options.sourceCodes
+            : [options.sourceCodes]
+        : [];
+    const files = [
+        ...filePathList,
+        ...codes.map((code, i) => ({
+            sourceCode: code,
+            name: Array.isArray(options.names) ? options.names?.[i] : options.names,
+            workspace: options.workspace?.[i],
+        })),
+    ];
+    let config;
+    let configFile;
+    if (typeof options.config === 'string') {
+        configFile = options.config;
+    }
+    else if (options.config) {
+        config = options.config;
+    }
+    const result = await lint(files, {
+        config,
+        configFile,
+        noSearchConfig: !options.files,
+        rules: options.rules,
+        autoLoad: options.rulesAutoResolve ?? true,
+        locale: options.locale,
+    });
+    return result;
+}